Parent

Methods

Included Modules

Files

StateMachine::TransitionCollection

Represents a collection of transitions in a state machine

Attributes

skip_actions[R]

Whether to skip running the action for each transition’s machine

skip_after[R]

Whether to skip running the after callbacks

use_transaction[R]

Whether transitions should wrapped around a transaction block

Public Instance Methods

perform(&block) click to toggle source

Runs each of the collection’s transitions in parallel.

All transitions will run through the following steps:

  1. Before callbacks

  2. Persist state

  3. Invoke action

  4. After callbacks (if configured)

  5. Rollback (if action is unsuccessful)

If a block is passed to this method, that block will be called instead of invoking each transition’s action.

# File lib/state_machine/transition_collection.rb, line 50
def perform(&block)
  reset
  
  if valid?
    if use_event_attributes? && !block_given?
      each do |transition|
        transition.transient = true
        transition.machine.write(object, :event_transition, transition)
      end
      
      run_actions
    else
      within_transaction do
        catch(:halt) { run_callbacks(&block) }
        rollback unless success?
      end
    end
  end
  
  if actions.length == 1 && results.include?(actions.first)
    results[actions.first]
  else
    success?
  end
end

Public Class Methods

new(transitions = [], options = {}) click to toggle source

Creates a new collection of transitions that can be run in parallel. Each transition must be for a different attribute.

Configuration options:

  • :actions - Whether to run the action configured for each transition

  • :after - Whether to run after callbacks

  • :transaction - Whether to wrap transitions within a transaction

# File lib/state_machine/transition_collection.rb, line 22
def initialize(transitions = [], options = {})
  super(transitions)
  
  # Determine the validity of the transitions as a whole
  @valid = all?
  reject! {|transition| !transition}
  
  attributes = map {|transition| transition.attribute}.uniq
  raise ArgumentError, 'Cannot perform multiple transitions in parallel for the same state machine attribute' if attributes.length != length
  
  assert_valid_keys(options, :actions, :after, :transaction)
  options = {:actions => true, :after => true, :transaction => true}.merge(options)
  @skip_actions = !options[:actions]
  @skip_after = !options[:after]
  @use_transaction = options[:transaction]
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.