joelind-state_machine 0.8.1

data/lib/state_machine/machine_collection.rb

@@ -0,0 +1,155 @@
+module StateMachine
+  # Represents a collection of state machines for a class
+  class MachineCollection < Hash
+    # Initializes the state of each machine in the given object.  Initial
+    # values are only set if the machine's attribute doesn't already exist
+    # (which must mean the defaults are being skipped)
+    def initialize_states(object, options = {})
+      if ignore = options[:ignore]
+        ignore.map! {|attribute| attribute.to_sym}
+      end
+      
+      each_value do |machine|
+        if (!ignore || !ignore.include?(machine.attribute)) && (!options.include?(:dynamic) || machine.dynamic_initial_state? == options[:dynamic])
+          value = machine.read(object, :state)
+          machine.write(object, :state, machine.initial_state(object).value) if ignore || value.nil? || value.respond_to?(:empty?) && value.empty?
+        end
+      end
+    end
+    
+    # Runs one or more events in parallel on the given object.  See
+    # StateMachine::InstanceMethods#fire_events for more information.
+    def fire_events(object, *events)
+      run_action = [true, false].include?(events.last) ? events.pop : true
+      
+      # Generate the transitions to run for each event
+      transitions = events.collect do |event_name|
+        # Find the actual event being run
+        event = nil
+        detect do |name, machine|
+          event = machine.events[event_name, :qualified_name]
+        end
+        
+        raise InvalidEvent, "#{event_name.inspect} is an unknown state machine event" unless event
+        
+        # Get the transition that will be performed for the event
+        unless transition = event.transition_for(object)
+          machine = event.machine
+          machine.invalidate(object, :state, :invalid_transition, [[:event, event_name]])
+        end
+        
+        transition
+      end.compact
+      
+      # Run the events in parallel only if valid transitions were found for
+      # all of them
+      if events.length == transitions.length
+        Transition.perform_within_transaction(transitions, :action => run_action)
+      else
+        false
+      end
+    end
+    
+    # Runs one or more event attributes in parallel during the invocation of
+    # an action on the given object.  after_transition callbacks can be
+    # optionally disabled if the events are being only partially fired (for
+    # example, when validating records in ORM integrations).
+    # 
+    # The event attributes that will be fired are based on which machines
+    # match the action that is being invoked.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     include DataMapper::Resource
+    #     property :id, Serial
+    #     
+    #     state_machine :initial => :parked do
+    #       event :ignite do
+    #         transition :parked => :idling
+    #       end
+    #     end
+    #     
+    #     state_machine :alarm_state, :namespace => 'alarm', :initial => :active do
+    #       event :disable do
+    #         transition all => :off
+    #       end
+    #     end
+    #   end
+    # 
+    # With valid events:
+    # 
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'ignite'
+    #   vehicle.alarm_state_event = 'disable'
+    #   
+    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save) { true }
+    #   vehicle.state                                 # => "idling"
+    #   vehicle.state_event                           # => nil
+    #   vehicle.alarm_state                           # => "off"
+    #   vehicle.alarm_state_event                     # => nil
+    # 
+    # With invalid events:
+    #   
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'park'
+    #   vehicle.alarm_state_event = 'disable'
+    #   
+    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save) { true }
+    #   vehicle.state                                 # => "parked"
+    #   vehicle.state_event                           # => nil
+    #   vehicle.alarm_state                           # => "active"
+    #   vehicle.alarm_state_event                     # => nil
+    #   vehicle.errors                                # => #<DataMapper::Validate::ValidationErrors:0xb7af9abc @errors={"state_event"=>["is invalid"]}>
+    # 
+    # With partial firing:
+    # 
+    #   vehicle = Vehicle.create                      # => #<Vehicle id=1 state="parked" alarm_state="active">
+    #   vehicle.state_event = 'ignite'
+    #   
+    #   Vehicle.state_machines.fire_event_attributes(vehicle, :save, false) { true }
+    #   vehicle.state                                 # => "idling"
+    #   vehicle.state_event                           # => "ignite"
+    #   vehicle.state_event_transition                # => #<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>
+    def fire_event_attributes(object, action, complete = true)
+      # Get the transitions to fire for each applicable machine
+      transitions = map {|name, machine| machine.action == action ? machine.events.attribute_transition_for(object, true) : nil}.compact
+      return yield if transitions.empty?
+      
+      # The value generated by the yielded block (the actual action)
+      action_value = nil
+      
+      # Make sure all events were valid
+      if result = transitions.all? {|transition| transition != false}
+        # Clear any traces of the event since transitions are available and to
+        # prevent from being evaluated multiple times if actions are nested
+        transitions.each do |transition|
+          transition.machine.write(object, :event, nil)
+          transition.machine.write(object, :event_transition, nil)
+        end
+        
+        # Perform the transitions
+        begin
+          result = Transition.perform(transitions, :after => complete) { action_value = yield }
+        rescue Exception
+          # Reset the event attribute so it can be re-evaluated if attempted again
+          transitions.each do |transition|
+            transition.machine.write(object, :event, transition.event)
+          end
+          
+          raise
+        end
+        
+        transitions.each do |transition|
+          # Revert event if failed (to allow for more attempts)
+          transition.machine.write(object, :event, transition.event) unless result
+          
+          # Track transition if partial transition was successful
+          transition.machine.write(object, :event_transition, transition) if !complete && result
+        end
+      end
+      
+      action_value.nil? ? result : action_value
+    end
+  end
+end

data/lib/state_machine/matcher.rb

@@ -0,0 +1,123 @@
+require 'singleton'
+
+module StateMachine
+  # Provides a general strategy pattern for determining whether a match is found
+  # for a value.  The algorithm that actually determines the match depends on
+  # the matcher in use.
+  class Matcher
+    # The list of values against which queries are matched
+    attr_reader :values
+    
+    # Creates a new matcher for querying against the given set of values
+    def initialize(values = [])
+      @values = values.is_a?(Array) ? values : [values] 
+    end
+    
+    # Generates a subset of values that exists in both the set of values being
+    # filtered and the values configured for the matcher
+    def filter(values)
+      self.values & values
+    end
+  end
+  
+  # Matches any given value.  Since there is no configuration for this type of
+  # matcher, it must be used as a singleton.
+  class AllMatcher < Matcher
+    include Singleton
+    
+    # Generates a blacklist matcher based on the given set of values
+    # 
+    # == Examples
+    # 
+    #   matcher = StateMachine::AllMatcher.instance - [:parked, :idling]
+    #   matcher.matches?(:parked)       # => false
+    #   matcher.matches?(:first_gear)   # => true
+    def -(blacklist)
+      BlacklistMatcher.new(blacklist)
+    end
+    
+    # Always returns true
+    def matches?(value, context = {})
+      true
+    end
+    
+    # Always returns the given set of values
+    def filter(values)
+      values
+    end
+    
+    # A human-readable description of this matcher.  Always "all".
+    def description
+      'all'
+    end
+  end
+  
+  # Matches a specific set of values
+  class WhitelistMatcher < Matcher
+    # Checks whether the given value exists within the whitelist configured
+    # for this matcher.
+    # 
+    # == Examples
+    # 
+    #   matcher = StateMachine::WhitelistMatcher.new([:parked, :idling])
+    #   matcher.matches?(:parked)       # => true
+    #   matcher.matches?(:first_gear)   # => false
+    def matches?(value, context = {})
+      values.include?(value)
+    end
+    
+    # A human-readable description of this matcher
+    def description
+      values.length == 1 ? values.first.inspect : values.inspect
+    end
+  end
+  
+  # Matches everything but a specific set of values
+  class BlacklistMatcher < Matcher
+    # Checks whether the given value exists outside the blacklist configured
+    # for this matcher.
+    # 
+    # == Examples
+    # 
+    #   matcher = StateMachine::BlacklistMatcher.new([:parked, :idling])
+    #   matcher.matches?(:parked)       # => false
+    #   matcher.matches?(:first_gear)   # => true
+    def matches?(value, context = {})
+      !values.include?(value)
+    end
+    
+    # Finds all values that are *not* within the blacklist configured for this
+    # matcher
+    def filter(values)
+      values - self.values
+    end
+    
+    # A human-readable description of this matcher
+    def description
+      "all - #{values.length == 1 ? values.first.inspect : values.inspect}"
+    end
+  end
+  
+  # Matches a loopback of two values within a context.  Since there is no
+  # configuration for this type of matcher, it must be used as a singleton.
+  class LoopbackMatcher < Matcher
+    include Singleton
+    
+    # Checks whether the given value matches what the value originally was.
+    # This value should be defined in the context.
+    # 
+    # == Examples
+    # 
+    #   matcher = StateMachine::LoopbackMatcher.instance
+    #   matcher.matches?(:parked, :from => :parked)   # => true
+    #   matcher.matches?(:parked, :from => :idling)   # => false
+    def matches?(value, context)
+      context[:from] == value
+    end
+    
+    # A human-readable description of this matcher.  Always "same".
+    def description
+      'same'
+    end
+  end
+end

data/lib/state_machine/matcher_helpers.rb

@@ -0,0 +1,54 @@
+module StateMachine
+  # Provides a set of helper methods for generating matchers
+  module MatcherHelpers
+    # Represents a state that matches all known states in a machine.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     state_machine do
+    #       before_transition any => :parked, :do => lambda {...}
+    #       before_transition all - :parked => all - :idling, :do => lambda {}
+    #       
+    #       event :park
+    #         transition all => :parked
+    #       end
+    #       
+    #       event :crash
+    #         transition all - :parked => :stalled
+    #       end
+    #     end
+    #   end
+    # 
+    # In the above example, +all+ will match the following states since they
+    # are known:
+    # * +parked+
+    # * +stalled+
+    # * +idling+
+    def all
+      AllMatcher.instance
+    end
+    alias_method :any, :all
+    
+    # Represents a state that matches the original +from+ state.  This is useful
+    # for defining transitions which are loopbacks.
+    # 
+    # == Examples
+    # 
+    #   class Vehicle
+    #     state_machine do
+    #       event :ignite
+    #         transition [:idling, :first_gear] => same
+    #       end
+    #     end
+    #   end
+    # 
+    # In the above example, +same+ will match whichever the from state is.  In
+    # the case of the +ignite+ event, it is essential the same as the following:
+    # 
+    #   transition :parked => :parked, :first_gear => :first_gear
+    def same
+      LoopbackMatcher.instance
+    end
+  end
+end

data/lib/state_machine/node_collection.rb

@@ -0,0 +1,152 @@
+require 'state_machine/assertions'
+
+module StateMachine
+  # Represents a collection of nodes in a state machine, be it events or states.
+  class NodeCollection
+    include Enumerable
+    include Assertions
+    
+    # The machine associated with the nodes
+    attr_reader :machine
+    
+    # Creates a new collection of nodes for the given state machine.  By default,
+    # the collection is empty.
+    # 
+    # Configuration options:
+    # * <tt>:index</tt> - One or more attributes to automatically generate
+    #   hashed indices for in order to perform quick lookups.  Default is to
+    #   index by the :name attribute
+    def initialize(machine, options = {})
+      assert_valid_keys(options, :index)
+      options = {:index => :name}.merge(options)
+      
+      @machine = machine
+      @nodes = []
+      @indices = Array(options[:index]).inject({}) {|indices, attribute| indices[attribute] = {}; indices}
+      @default_index = Array(options[:index]).first
+    end
+    
+    # Creates a copy of this collection such that modifications don't affect
+    # the original collection
+    def initialize_copy(orig) #:nodoc:
+      super
+      
+      nodes = @nodes
+      @nodes = []
+      @indices = @indices.inject({}) {|indices, (name, index)| indices[name] = {}; indices}
+      nodes.each {|node| self << node.dup}
+    end
+    
+    # Changes the current machine associated with the collection.  In turn, this
+    # will change the state machine associated with each node in the collection.
+    def machine=(new_machine)
+      @machine = new_machine
+      each {|node| node.machine = new_machine}
+    end
+    
+    # Gets the number of nodes in this collection
+    def length
+      @nodes.length
+    end
+    
+    # Gets the set of unique keys for the given index
+    def keys(index_name = @default_index)
+      index(index_name).keys
+    end
+    
+    # Adds a new node to the collection.  By doing so, this will also add it to
+    # the configured indices.
+    def <<(node)
+      @nodes << node
+      @indices.each {|attribute, index| index[value(node, attribute)] = node}
+      self
+    end
+    
+    # Updates the indexed keys for the given node.  If the node's attribute
+    # has changed since it was added to the collection, the old indexed keys
+    # will be replaced with the updated ones.
+    def update(node)
+      @indices.each do |attribute, index|
+        old_key = RUBY_VERSION < '1.9' ? index.index(node) : index.key(node)
+        new_key = value(node, attribute)
+        
+        # Only replace the key if it's changed
+        if old_key != new_key
+          index.delete(old_key)
+          index[new_key] = node
+        end
+      end
+    end
+    
+    # Calls the block once for each element in self, passing that element as a
+    # parameter.
+    # 
+    #   states = StateMachine::NodeCollection.new
+    #   states << StateMachine::State.new(machine, :parked)
+    #   states << StateMachine::State.new(machine, :idling)
+    #   states.each {|state| puts state.name, ' -- '}
+    # 
+    # ...produces:
+    # 
+    #   parked -- idling --
+    def each
+      @nodes.each {|node| yield node}
+      self
+    end
+    
+    # Gets the node at the given index.
+    # 
+    #   states = StateMachine::NodeCollection.new
+    #   states << StateMachine::State.new(machine, :parked)
+    #   states << StateMachine::State.new(machine, :idling)
+    #   
+    #   states.at(0).name    # => :parked
+    #   states.at(1).name    # => :idling
+    def at(index)
+      @nodes[index]
+    end
+    
+    # Gets the node indexed by the given key.  By default, this will look up the
+    # key in the first index configured for the collection.  A custom index can
+    # be specified like so:
+    # 
+    #   collection['parked', :value]
+    # 
+    # The above will look up the "parked" key in a hash indexed by each node's
+    # +value+ attribute.
+    # 
+    # If the key cannot be found, then nil will be returned.
+    def [](key, index_name = @default_index)
+      index(index_name)[key]
+    end
+    
+    # Gets the node indexed by the given key.  By default, this will look up the
+    # key in the first index configured for the collection.  A custom index can
+    # be specified like so:
+    # 
+    #   collection['parked', :value]
+    # 
+    # The above will look up the "parked" key in a hash indexed by each node's
+    # +value+ attribute.
+    # 
+    # If the key cannot be found, then an IndexError exception will be raised:
+    # 
+    #   collection['invalid', :value]   # => IndexError: "invalid" is an invalid value
+    def fetch(key, index_name = @default_index)
+      self[key, index_name] || raise(IndexError, "#{key.inspect} is an invalid #{index_name}")
+    end
+    
+    private
+      # Gets the given index.  If the index does not exist, then an ArgumentError
+      # is raised.
+      def index(name)
+        raise ArgumentError, 'No indices configured' unless @indices.any?
+        @indices[name] || raise(ArgumentError, "Invalid index: #{name.inspect}")
+      end
+      
+      # Gets the value for the given attribute on the node
+      def value(node, attribute)
+        node.send(attribute)
+      end
+  end
+end