### Home Classes Methods

### In Files

- lib/state_machine/machine_collection.rb

### Parent

Hash

### Methods

- #fire_events
- #initialize_states
- #transitions

### Included Modules

- StateMachine::Assertions

### Files

- LICENSE

### Class/Module Index

Quicksearch

- StateMachine
- StateMachine::AllMatcher
- StateMachine::Assertions
- StateMachine::AttributeTransitionCollection
- StateMachine::BlacklistMatcher
- StateMachine::Branch
- StateMachine::Callback
- StateMachine::ClassMethods
- StateMachine::Error
- StateMachine::EvalHelpers
- StateMachine::Event
- StateMachine::EventCollection
- StateMachine::Graph
- StateMachine::InstanceMethods
- StateMachine::IntegrationNotFound
- StateMachine::Integrations
- StateMachine::Integrations::ActiveModel
- StateMachine::Integrations::ActiveModel::Observer
- StateMachine::Integrations::ActiveModel::ObserverUpdate
- StateMachine::Integrations::ActiveRecord
- StateMachine::Integrations::Base
- StateMachine::Integrations::Base::ClassMethods
- StateMachine::Integrations::DataMapper
- StateMachine::Integrations::DataMapper::Observer
- StateMachine::Integrations::MongoMapper
- StateMachine::Integrations::Mongoid
- StateMachine::Integrations::Sequel
- StateMachine::InvalidEvent
- StateMachine::InvalidParallelTransition
- StateMachine::InvalidTransition
- StateMachine::LoopbackMatcher
- StateMachine::Machine
- StateMachine::MachineCollection
- StateMachine::MacroMethods
- StateMachine::Matcher
- StateMachine::MatcherHelpers
- StateMachine::NodeCollection
- StateMachine::Path
- StateMachine::PathCollection
- StateMachine::RailsEngine
- StateMachine::State
- StateMachine::StateCollection
- StateMachine::StateContext
- StateMachine::Transition
- StateMachine::TransitionCollection
- StateMachine::WhitelistMatcher
- StateMachine::YARD
- StateMachine::YARD::Handlers
- StateMachine::YARD::Handlers::Base
- StateMachine::YARD::Handlers::Event
- StateMachine::YARD::Handlers::Machine
- StateMachine::YARD::Handlers::State
- StateMachine::YARD::Handlers::Transition
- Object

No matching classes.

# StateMachine::MachineCollection

Represents a collection of state machines for a class

### Public Instance Methods

fire_events(object, *events) click to toggle source

Runs one or more events in parallel on the given object. See StateMachine::InstanceMethods#fire_events for more information.

    # File lib/state_machine/machine_collection.rb, line 45
    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 {|name, machine| event = machine.events[event_name, :qualified_name]}

        raise(InvalidEvent.new(object, event_name)) unless event

        # Get the transition that will be performed for the event
        unless transition = event.transition_for(object)
          event.on_failure(object)
        end

        transition
      end.compact

      # Run the events in parallel only if valid transitions were found for
      # all of them
      if events.length == transitions.length
        TransitionCollection.new(transitions, :actions => run_action).perform
      else
        false
      end
    end

initialize_states(object, options = {}) click to toggle source

Initializes the state of each machine in the given object. This can allow states to be initialized in two groups: static and dynamic. For example:

    machines.initialize_states(object) do
      # After static state initialization, before dynamic state initialization
    end

If no block is provided, then all states will still be initialized.

Valid configuration options:

- `:static` - Whether to initialize static states. If set to :force, the state will be initialized regardless of its current value. Default is :force.

- `:dynamic` - Whether to initialize dynamic states. If set to :force, the state will be initialized regardless of its current value. Default is true.

- `:to` - A hash to write the initialized state to instead of writing to the object. Default is to write directly to the object.

    # File lib/state_machine/machine_collection.rb, line 26
    def initialize_states(object, options = {})
      assert_valid_keys(options, :static, :dynamic, :to)
      options = {:static => true, :dynamic => true}.merge(options)

      each_value do |machine|
        machine.initialize_state(object, :force => options[:static] == :force, :to => options[:to]) unless machine.dynamic_initial_state?
      end if options[:static]

      result = yield if block_given?

      each_value do |machine|
        machine.initialize_state(object, :force => options[:dynamic] == :force, :to => options[:to]) if machine.dynamic_initial_state?
      end if options[:dynamic]

      result
    end

transitions(object, action, options = {}) click to toggle source

Builds the collection of transitions for all event attributes defined on the given object. This will only include events whose machine actions match the one specified.

These should only be fired as a result of the action being run.

    # File lib/state_machine/machine_collection.rb, line 78
    def transitions(object, action, options = {})
      transitions = map do |name, machine|
        machine.events.attribute_transition_for(object, true) if machine.action == action
      end

      AttributeTransitionCollection.new(transitions.compact, options)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.