Passing arrays of states as :to values

[pacso]

When configuring a transition you can either pass a single state as a string or symbol as the :to argument, or alternatively you can configure multiple transitions by passing an array of strings or symbols.

However, it seems that transition is the only method which accepts arrays when configuring a state machine.

Why do none of the others, such as the before_transition, after_transition callbacks or the guards accept an array of states? Is it a conscious design decision or just something you've not implemented through lack of requirement on your part?

For example, I have a payment system which accepts online payments by cards, or postal payments by cheque. It has a simple state machine:

class OrderStateMachine
  include Statesman::Machine

  state :pending, initial: true
  state :card_payment_declined
  state :card_payment_captured
  state :waiting_cheque
  state :cheque_received

  event :transaction_processed do
    transition from: :pending, to: [:card_payment_captured, :card_payment_declined]
    transition from: :card_payment_declined, to: [:card_payment_captured, :card_payment_declined]
  end

  event :wait_for_postal_payment do
    transition from: :pending, to: :waiting_cheque
  end

  event :cheque_received do
    transition from: :waiting_cheque, to: :cheque_received
  end

  guard_transition to: :card_payment_captured do |object, last_transition, metadata|
    metadata[:action] == 'purchase' && metadata[:success]
  end
end

This uses my modified version of statesman as detailed in pull request #78 which allows the state machine to decide which state to transition to when the :transaction_processed event is triggered based on the metadata passed in from my payment service object.

As you can see, the completion state for card payments is :card_payment_captured, whilst the completion state for postal orders is :cheque_received. However, in both of these cases, once that state is reached, the associated order items need to be marked as paid so that they can be processed.

I would like to be able to use the following syntax when configuring this sort of post-transition processing within a state machine:

  after_transition to: [:card_payment_captured, :cheque_received] do |order|
    order.order_items.each { |order_item| order_item.trigger! :payment_received }
  end

With the existing code I would have to write two separate after_transition callbacks with identical contents, which just doesn't feel right. Before you suggest that I move to a state machine with a single :paid end-state, I'd rather keep the two payment types segregated.

What do you think?

[isaacseymour]

I really like this, much more consistent. I've implemented it in #82 (I think), so would be great if you could take a look at that.

[pacso]

As I commented on the PR - I'll pull a copy of this branch and test the new syntax against my existing code. Thanks for this!

[jackfranklin]

This is now done now #83 is merged in.