Add when and events methods.

README.md

@@ -11,7 +11,7 @@ all provide a nice DSL for declaring events, exceptions, callbacks,
 and all kinds of niceties in general.
 
 But if all you want is a finite state machine, look no further: this
-is only 22 lines of code and provides everything a finite state
+has less than 50 lines of code and provides everything a finite state
 machine must have, and nothing more.
 
 Usage
@@ -22,9 +22,10 @@ require 'micromachine'
 
 machine = MicroMachine.new(:new) # Initial state.
 
-machine.transitions_for[:confirm] = { :new => :confirmed }
-machine.transitions_for[:ignore]  = { :new => :ignored }
-machine.transitions_for[:reset]   = { :confirmed => :new, :ignored => :new }
+# Define the possible transitions for each event.
+machine.when(:confirm, :new => :confirmed)
+machine.when(:ignore, :new => :ignored)
+machine.when(:reset, :confirmed => :new, :ignored => :new)
 
 machine.trigger(:confirm)  #=> true
 machine.state              #=> :confirmed
@@ -39,6 +40,15 @@ machine.trigger(:ignore)   #=> true
 machine.state              #=> :ignored
 ```
 
+The `when` helper is syntactic sugar for assigning to the
+`transitions_for` hash. This code is equivalent:
+
+``` ruby
+machine.transitions_for[:confirm] = { :new => :confirmed }
+machine.transitions_for[:ignore]  = { :new => :ignored }
+machine.transitions_for[:reset]   = { :confirmed => :new, :ignored => :new }
+```
+
 You can also ask if an event will trigger a change in state. Following
 the example above:
 
@@ -103,9 +113,9 @@ class Event < ActiveRecord::Base
     @confirmation ||= begin
       fsm = MicroMachine.new(confirmation_state || "pending")
 
-      fsm.transitions_for[:confirm] = { "pending" => "confirmed" }
-      fsm.transitions_for[:cancel] = { "confirmed" => "cancelled" }
-      fsm.transitions_for[:reset] = { "confirmed" => "pending", "cancelled" => "pending" }
+      fsm.when(:confirm, "pending" => "confirmed")
+      fsm.when(:cancel, "confirmed" => "cancelled")
+      fsm.when(:reset, "confirmed" => "pending", "cancelled" => "pending")
 
       fsm
     end
@@ -143,9 +153,9 @@ class Event < ActiveRecord::Base
     @confirmation ||= begin
       fsm = MicroMachine.new(confirmation_state || "pending")
 
-      fsm.transitions_for[:confirm] = { "pending" => "confirmed" }
-      fsm.transitions_for[:cancel] = { "confirmed" => "cancelled" }
-      fsm.transitions_for[:reset] = { "confirmed" => "pending", "cancelled" => "pending" }
+      fsm.when(:confirm, "pending" => "confirmed")
+      fsm.when(:cancel, "confirmed" => "cancelled")
+      fsm.when(:reset, "confirmed" => "pending", "cancelled" => "pending")
 
       fsm.on(:any) { self.confirmation_state = confirmation.state }
 

examples/advanced.rb

@@ -4,9 +4,9 @@
 
 fsm = MicroMachine.new(:pending)
 
-fsm.transitions_for[:confirm] = { :pending => :confirmed }
-fsm.transitions_for[:ignore]  = { :pending => :ignored }
-fsm.transitions_for[:reset]   = { :confirmed => :pending, :ignored => :pending }
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
 
 puts "Should print Confirmed, Pending and Ignored:"
 

examples/basic.rb

@@ -4,9 +4,9 @@
 
 fsm = MicroMachine.new(:pending)
 
-fsm.transitions_for[:confirm] = { :pending => :confirmed }
-fsm.transitions_for[:ignore]  = { :pending => :ignored }
-fsm.transitions_for[:reset]   = { :confirmed => :pending, :ignored => :pending }
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
 
 puts "Should print Confirmed, Reset and Ignored:"
 

examples/callbacks.rb

@@ -4,9 +4,9 @@
 
 fsm = MicroMachine.new(:pending)
 
-fsm.transitions_for[:confirm] = { :pending => :confirmed }
-fsm.transitions_for[:ignore]  = { :pending => :ignored }
-fsm.transitions_for[:reset]   = { :confirmed => :pending, :ignored => :pending }
+fsm.when(:confirm,  :pending => :confirmed)
+fsm.when(:ignore,   :pending => :ignored)
+fsm.when(:reset,    :confirmed => :pending, :ignored => :pending)
 
 puts "Should print Confirmed, Reset and Ignored:"
 

lib/micromachine.rb

@@ -14,6 +14,10 @@ def on key, &block
     @callbacks[key] << block
   end
 
+  def when(event, transitions)
+    transitions_for[event] = transitions
+  end
+
   def trigger event
     if trigger?(event)
       @state = transitions_for[event][@state]
@@ -31,6 +35,10 @@ def trigger?(event)
     raise InvalidEvent
   end
 
+  def events
+    transitions_for.keys
+  end
+
   def ==(some_state)
     state == some_state
   end

test/all_test.rb

@@ -42,12 +42,39 @@ class MicroMachineTest < Test::Unit::TestCase
     end
   end
 
+  context "using when for defining transitions" do
+    setup do
+      @machine = MicroMachine.new(:pending)
+      @machine.when(:confirm, :pending => :confirmed)
+      @machine.when(:ignore, :pending => :ignored)
+      @machine.when(:reset, :confirmed => :pending, :ignored => :pending)
+    end
+
+    should "discern transitions" do
+      assert_equal true, @machine.trigger?(:confirm)
+      assert_equal true, @machine.trigger(:confirm)
+      assert_equal :confirmed, @machine.state
+
+      assert_equal false, @machine.trigger?(:ignore)
+      assert_equal false, @machine.trigger(:ignore)
+      assert_equal :confirmed, @machine.state
+
+      assert_equal true, @machine.trigger?(:reset)
+      assert_equal true, @machine.trigger(:reset)
+      assert_equal :pending, @machine.state
+
+      assert_equal true, @machine.trigger?(:ignore)
+      assert_equal true, @machine.trigger(:ignore)
+      assert_equal :ignored, @machine.state
+    end
+  end
+
   context "dealing with callbacks" do
     setup do
       @machine = MicroMachine.new(:pending)
-      @machine.transitions_for[:confirm]  = { :pending => :confirmed }
-      @machine.transitions_for[:ignore]   = { :pending => :ignored }
-      @machine.transitions_for[:reset]    = { :confirmed => :pending, :ignored => :pending }
+      @machine.when(:confirm, :pending => :confirmed)
+      @machine.when(:ignore, :pending => :ignored)
+      @machine.when(:reset, :confirmed => :pending, :ignored => :pending)
 
       @machine.on(:pending)   { @state = "Pending" }
       @machine.on(:confirmed) { @state = "Confirmed" }
@@ -80,13 +107,13 @@ class Model
 
       def machine
         @machine ||= begin
-                       machine = MicroMachine.new(:pending)
-                       machine.transitions_for[:confirm]  = { :pending => :confirmed }
-                       machine.transitions_for[:ignore]   = { :pending => :ignored }
-                       machine.transitions_for[:reset]    = { :confirmed => :pending, :ignored => :pending }
-                       machine.on(:any)       { self.state = machine.state }
-                       machine
-                     end
+          machine = MicroMachine.new(:pending)
+          machine.when(:confirm, :pending => :confirmed)
+          machine.when(:ignore, :pending => :ignored)
+          machine.when(:reset, :confirmed => :pending, :ignored => :pending)
+          machine.on(:any) { self.state = machine.state }
+          machine
+        end
       end
     end