state_machines 0.4.0 → 0.6.0

data/lib/state_machines/event.rb

@@ -12,7 +12,7 @@ module StateMachines
     # The name of the event
     attr_reader :name
 
-    # The fully-qualified name of the event, scoped by the machine's namespace 
+    # The fully-qualified name of the event, scoped by the machine's namespace
     attr_reader :qualified_name
 
     # The human-readable name for the event
@@ -27,7 +27,7 @@ module StateMachines
     attr_reader :known_states
 
     # Creates a new event within the context of the given machine
-    # 
+    #
     # Configuration options:
     # * <tt>:human_name</tt> - The human-readable version of this event's name
     def initialize(machine, name, options = {}) #:nodoc:
@@ -40,7 +40,7 @@ module StateMachines
       reset
 
       # Output a warning if another event has a conflicting qualified name
-      if conflict = machine.owner_class.state_machines.detect { |_other_name, other_machine| other_machine != @machine && other_machine.events[qualified_name, :qualified_name] }
+      if (conflict = machine.owner_class.state_machines.detect { |_other_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
@@ -70,18 +70,18 @@ module StateMachines
 
     # Creates a new transition that determines what to change the current state
     # to when this event fires.
-    # 
+    #
     # Since this transition is being defined within an event context, you do
     # *not* need to specify the <tt>:on</tt> option for the transition.  For
     # example:
-    # 
+    #
     #  state_machine do
     #    event :ignite do
     #      transition :parked => :idling, :idling => same, :if => :seatbelt_on? # Transitions to :idling if seatbelt is on
     #      transition all => :parked, :unless => :seatbelt_on?                  # Transitions to :parked if seatbelt is off
     #    end
     #  end
-    # 
+    #
     # See StateMachines::Machine#transition for a description of the possible
     # configurations for defining transitions.
     def transition(options)
@@ -91,16 +91,16 @@ module StateMachines
       # requirements
       options.assert_valid_keys(:from, :to, :except_from, :except_to, :if, :unless) if (options.keys - [:from, :to, :on, :except_from, :except_to, :except_on, :if, :unless]).empty?
 
-      branches << branch = Branch.new(options.merge(:on => name))
+      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.
-    # 
+    #
     # *Note* that this will not take the object context into account.  Although
     # a transition may be possible based on the state machine definition,
     # object-specific behaviors (like validations) may prevent it from firing.
@@ -110,7 +110,7 @@ module StateMachines
 
     # 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.
@@ -120,10 +120,10 @@ module StateMachines
     #   conditionals defined for each one.  Default is true.
     def transition_for(object, requirements = {})
       requirements.assert_valid_keys(:from, :to, :guard)
-      requirements[:from] = machine.states.match!(object).name unless custom_from_state = requirements.include?(:from)
+      requirements[:from] = machine.states.match!(object).name unless (custom_from_state = requirements.include?(:from))
 
       branches.each do |branch|
-        if match = branch.match(object, requirements)
+        if (match = branch.match(object, requirements))
           # Branch allows for the transition to occur
           from = requirements[:from]
           to = if match[:to].is_a?(LoopbackMatcher)
@@ -145,27 +145,29 @@ module StateMachines
     # Attempts to perform the next available transition on the given object.
     # If no transitions can be made, then this will return false, otherwise
     # true.
-    # 
+    #
     # Any additional arguments are passed to the StateMachines::Transition#perform
     # instance method.
     def fire(object, *args)
       machine.reset(object)
 
-      if transition = transition_for(object)
+      if (transition = transition_for(object))
         transition.perform(*args)
       else
-        on_failure(object)
+        on_failure(object, *args)
         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)
+    def on_failure(object, *args)
       state = machine.states.match!(object)
       machine.invalidate(object, :state, :invalid_transition, [[:event, human_name(object.class)], [:state, state.human_name(object.class)]])
 
-      Transition.new(object, machine, name, state.name, state.name).run_callbacks(:before => false)
+      transition = Transition.new(object, machine, name, state.name, state.name)
+      transition.args = args if args.any?
+      transition.run_callbacks(before: false)
     end
 
     # Resets back to the initial state of the event, with no branches / known
@@ -183,9 +185,9 @@ module StateMachines
     end
 
     # Generates a nicely formatted description of this event's contents.
-    # 
+    #
     # For example,
-    # 
+    #
     #   event = StateMachines::Event.new(machine, :park)
     #   event.transition all - :idling => :parked, :idling => same
     #   event   # => #<StateMachines::Event name=:park transitions=[all - :idling => :parked, :idling => same]>
@@ -199,29 +201,30 @@ module StateMachines
       "#<#{self.class} name=#{name.inspect} transitions=[#{transitions * ', '}]>"
     end
 
-    protected
+  protected
+
     # Add the various instance methods that can transition the object using
     # the current event
     def add_actions
       # Checks whether the event can be fired on the current object
-      machine.define_helper(:instance, "can_#{qualified_name}?") do |machine, object, *args|
-        machine.event(name).can_fire?(object, *args)
+      machine.define_helper(:instance, "can_#{qualified_name}?") do |machine, object, *args, **kwargs|
+        machine.event(name).can_fire?(object, *args, **kwargs)
       end
 
       # Gets the next transition that would be performed if the event were
       # fired now
-      machine.define_helper(:instance, "#{qualified_name}_transition") do |machine, object, *args|
-        machine.event(name).transition_for(object, *args)
+      machine.define_helper(:instance, "#{qualified_name}_transition") do |machine, object, *args, **kwargs|
+        machine.event(name).transition_for(object, *args, **kwargs)
       end
 
       # Fires the event
-      machine.define_helper(:instance, qualified_name) do |machine, object, *args|
-        machine.event(name).fire(object, *args)
+      machine.define_helper(:instance, qualified_name) do |machine, object, *args, **kwargs|
+        machine.event(name).fire(object, *args, **kwargs)
       end
 
       # Fires the event, raising an exception if it fails
-      machine.define_helper(:instance, "#{qualified_name}!") do |machine, object, *args|
-        object.send(qualified_name, *args) || raise(StateMachines::InvalidTransition.new(object, machine, name))
+      machine.define_helper(:instance, "#{qualified_name}!") do |machine, object, *args, **kwargs|
+        object.send(qualified_name, *args, **kwargs) || raise(StateMachines::InvalidTransition.new(object, machine, name))
       end
     end
   end

data/lib/state_machines/event_collection.rb

@@ -2,11 +2,11 @@ module StateMachines
   # Represents a collection of events in a state machine
   class EventCollection < NodeCollection
     def initialize(machine) #:nodoc:
-      super(machine, :index => [:name, :qualified_name])
+      super(machine, index: [:name, :qualified_name])
     end
 
     # 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.
@@ -16,26 +16,26 @@ module StateMachines
     #   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
     #     state_machine :initial => :parked do
     #       event :park do
     #         transition :idling => :parked
     #       end
-    #       
+    #
     #       event :ignite do
     #         transition :parked => :idling
     #       end
     #     end
     #   end
-    #   
+    #
     #   events = Vehicle.state_machine(:state).events
-    #   
+    #
     #   vehicle = Vehicle.new               # => #<Vehicle:0xb7c464b0 @state="parked">
     #   events.valid_for(vehicle)           # => [#<StateMachines::Event name=:ignite transitions=[:parked => :idling]>]
-    #   
+    #
     #   vehicle.state = 'idling'
     #   events.valid_for(vehicle)           # => [#<StateMachines::Event name=:park transitions=[:idling => :parked]>]
     def valid_for(object, requirements = {})
@@ -43,7 +43,7 @@ module StateMachines
     end
 
     # Gets the list of transitions that can be run 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.
@@ -53,29 +53,29 @@ module StateMachines
     #   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
     #     state_machine :initial => :parked do
     #       event :park do
     #         transition :idling => :parked
     #       end
-    #       
+    #
     #       event :ignite do
     #         transition :parked => :idling
     #       end
     #     end
     #   end
-    #   
+    #
     #   events = Vehicle.state_machine.events
-    #   
+    #
     #   vehicle = Vehicle.new                             # => #<Vehicle:0xb7c464b0 @state="parked">
     #   events.transitions_for(vehicle)                   # => [#<StateMachines::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>]
-    #   
+    #
     #   vehicle.state = 'idling'
     #   events.transitions_for(vehicle)                   # => [#<StateMachines::Transition attribute=:state event=:park from="idling" from_name=:idling to="parked" to_name=:parked>]
-    #   
+    #
     #   # Search for explicit transitions regardless of the current state
     #   events.transitions_for(vehicle, :from => :parked) # => [#<StateMachines::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>]
     def transitions_for(object, requirements = {})
@@ -86,12 +86,12 @@ module StateMachines
     # given object's event attribute.  This also takes an additional parameter
     # for automatically invalidating the object if the event or transition are
     # invalid.  By default, this is turned off.
-    # 
+    #
     # *Note* that if a transition has already been generated for the event, then
     # that transition will be used.
-    # 
+    #
     # == Examples
-    # 
+    #
     #   class Vehicle < ActiveRecord::Base
     #     state_machine :initial => :parked do
     #       event :ignite do
@@ -99,16 +99,16 @@ module StateMachines
     #       end
     #     end
     #   end
-    #   
+    #
     #   vehicle = Vehicle.new                       # => #<Vehicle id: nil, state: "parked">
     #   events = Vehicle.state_machine.events
-    #   
+    #
     #   vehicle.state_event = nil
     #   events.attribute_transition_for(vehicle)    # => nil # Event isn't defined
-    #   
+    #
     #   vehicle.state_event = 'invalid'
     #   events.attribute_transition_for(vehicle)    # => false # Event is invalid
-    #   
+    #
     #   vehicle.state_event = 'ignite'
     #   events.attribute_transition_for(vehicle)    # => #<StateMachines::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
     def attribute_transition_for(object, invalidate = false)
@@ -118,7 +118,7 @@ module StateMachines
       machine.read(object, :event_transition) || if event_name = machine.read(object, :event)
                                                    if event = self[event_name.to_sym, :name]
                                                      event.transition_for(object) || begin
-                                                                                       # No valid transition: invalidate
+                                                       # No valid transition: invalidate
                                                        machine.invalidate(object, :event, :invalid_event, [[:state, machine.states.match!(object).human_name(object.class)]]) if invalidate
                                                        false
                                                      end
@@ -131,7 +131,8 @@ module StateMachines
 
     end
 
-    private
+  private
+
     def match(requirements) #:nodoc:
       requirements && requirements[:on] ? [fetch(requirements.delete(:on))] : self
     end

data/lib/state_machines/extensions.rb

@@ -133,13 +133,13 @@ module StateMachines
     #   vehicle = Vehicle.new                         # => #<Vehicle:0xb7c02850 @state="parked", @alarm_state="active">
     #   vehicle.fire_events(:ignite, :disable_alarm)  # => true
     #
-    #   vehicle.fire_events!(:ignite, :disable_alarm) # => StateMachines::InvalidTranstion: Cannot run events in parallel: ignite, disable_alarm
+    #   vehicle.fire_events!(:ignite, :disable_alarm) # => StateMachines::InvalidParallelTransition: 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])) || fail(StateMachines::InvalidParallelTransition.new(self, events))
     end
 
-    protected
+  protected
 
     def initialize_state_machines(options = {}, &block) #:nodoc:
       self.class.state_machines.initialize_states(self, options, &block)

data/lib/state_machines/helper_module.rb

@@ -6,7 +6,7 @@ module StateMachines
       @machine = machine
       @kind = kind
     end
-    
+
     # Provides a human-readable description of the module
     def to_s
       owner_class = @machine.owner_class

data/lib/state_machines/integrations/base.rb

@@ -24,20 +24,17 @@ module StateMachines
 
         # Whether the integration should be used for the given class.
         def matches?(klass)
-          matches_ancestors?(klass.ancestors.map { |ancestor| ancestor.name })
+          matching_ancestors.any? { |ancestor| klass <= ancestor }
         end
 
         # Whether the integration should be used for the given list of ancestors.
         def matches_ancestors?(ancestors)
           (ancestors & matching_ancestors).any?
         end
-
       end
 
-      extend ClassMethods
-
       def self.included(base) #:nodoc:
-        base.class_eval { extend ClassMethods }
+        base.extend ClassMethods
       end
     end
   end

data/lib/state_machines/integrations.rb

@@ -1,5 +1,3 @@
-require 'set'
-
 module StateMachines
   # Integrations allow state machines to take advantage of features within the
   # context of a particular library.  This is currently most useful with
@@ -11,10 +9,10 @@ module StateMachines
   # * Scopes
   # * Callbacks
   # * Validation errors
-  # 
+  #
   # This type of integration allows the user to work with state machines in a
   # fashion similar to other object models in their application.
-  # 
+  #
   # The integration interface is loosely defined by various unimplemented
   # methods in the StateMachines::Machine class.  See that class or the various
   # built-in integrations for more information about how to define additional
@@ -54,24 +52,23 @@ module StateMachines
 
       alias_method :list, :integrations
 
-
       # Attempts to find an integration that matches the given class.  This will
       # look through all of the built-in integrations under the StateMachines::Integrations
       # namespace and find one that successfully matches the class.
-      # 
+      #
       # == Examples
-      # 
+      #
       #   class Vehicle
       #   end
-      #   
+      #
       #   class ActiveModelVehicle
       #     include ActiveModel::Observing
       #     include ActiveModel::Validations
       #   end
-      #   
+      #
       #   class ActiveRecordVehicle < ActiveRecord::Base
       #   end
-      #   
+      #
       #   StateMachines::Integrations.match(Vehicle)             # => nil
       #   StateMachines::Integrations.match(ActiveModelVehicle)  # => StateMachines::Integrations::ActiveModel
       #   StateMachines::Integrations.match(ActiveRecordVehicle) # => StateMachines::Integrations::ActiveRecord
@@ -86,7 +83,7 @@ module StateMachines
       # == Examples
       #
       #   StateMachines::Integrations.match_ancestors([])                    # => nil
-      #   StateMachines::Integrations.match_ancestors(['ActiveRecord::Base']) # => StateMachines::Integrations::ActiveModel
+      #   StateMachines::Integrations.match_ancestors([ActiveRecord::Base]) # => StateMachines::Integrations::ActiveModel
       def match_ancestors(ancestors)
         integrations.detect { |integration| integration.matches_ancestors?(ancestors) }
       end
@@ -103,8 +100,7 @@ module StateMachines
         integrations.detect { |integration| integration.integration_name == name } || raise(IntegrationNotFound.new(name))
       end
 
-
-      private
+    private
 
       def add(integration)
         if integration.respond_to?(:integration_name)