edge-state-machine 0.0.2 → 0.0.3

data/spec/mongoid/mongoid_spec.rb

@@ -1,99 +1,5 @@
 require 'mongoid/mongoid_helper'
 
-class MongoTrafficLight
-  include Mongoid::Document
-  include Mongoid::EdgeStateMachine
-  field :state
-
-  state_machine do
-    state :off
-
-    state :red
-    state :green
-    state :yellow
-
-    event :red_on do
-      transitions :to => :red, :from => [:yellow]
-    end
-
-    event :green_on do
-      transitions :to => :green, :from => [:red]
-    end
-
-    event :yellow_on do
-      transitions :to => :yellow, :from => [:green]
-    end
-
-    event :reset do
-      transitions :to => :red, :from => [:off]
-    end
-  end
-end
-
-class MongoProtectedTrafficLight < MongoTrafficLight
-  attr_protected :state
-end
-
-class MongoValidatingTrafficLight < MongoTrafficLight
-  validate {|t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
-end
-
-class MongoConditionalValidatingTrafficLight < MongoTrafficLight
-  validates :name, :presence => true, :length  => { :within => 20..40 }, :confirmation => true, :if => :red?
-end
-
-class MongoOrder
-  include Mongoid::Document
-  include Mongoid::EdgeStateMachine
-
-  field :state, :type => String
-  field :order_number, :type => Integer
-  field :paid_at, :type => DateTime
-  field :prepared_on, :type => DateTime
-  field :dispatched_at, :type => DateTime
-  field :cancellation_date, :type => Date
-
-  state_machine do
-    state :opened
-    state :placed
-    state :paid
-    state :prepared
-    state :delivered
-    state :cancelled
-
-    # no timestamp col is being specified here - should be ignored
-    event :place do
-      transitions :from => :opened, :to => :placed
-    end
-
-    # should set paid_at timestamp
-    event :pay, :timestamp => true do
-      transitions :from => :placed, :to => :paid
-    end
-
-    # should set prepared_on
-    event :prepare, :timestamp => true do
-      transitions :from => :paid, :to => :prepared
-    end
-
-    # should set dispatched_at
-    event :deliver, :timestamp => "dispatched_at" do
-      transitions :from => :prepared, :to => :delivered
-    end
-
-    # should set cancellation_date
-    event :cancel, :timestamp => :cancellation_date do
-      transitions :from => [:placed, :paid, :prepared], :to => :cancelled
-    end
-
-    # should raise an exception as there is no timestamp col
-    event :reopen, :timestamp => true do
-      transitions :from => :cancelled, :to => :opened
-    end
-
-  end
-end
-
 describe "mongoid state machine" do
 
   context "existing mongo document" do
@@ -121,7 +27,7 @@ describe "mongoid state machine" do
       @light.reset
       @light.current_state.should == :red
       @light.reload
-      @light.state.should == "off"
+      @light.state.should == :off
     end
 
     it "should persists state on transition" do
@@ -131,8 +37,14 @@ describe "mongoid state machine" do
       @light.state.should == "red"
     end
 
+    it "should initialize the current state when loaded from database" do
+      @light.reset!
+      loaded_light = MongoTrafficLight.find(@light.id)
+      loaded_light.current_state.should == :red
+    end
+
     it "should raise error on transition to an invalid state" do
-      expect { @light.yellow_on }.should raise_error EdgeStateMachine::InvalidTransition
+      expect { @light.yellow_on }.should raise_error EdgeStateMachine::NoTransitionFound
       @light.current_state.should == :off
     end
 
@@ -145,8 +57,8 @@ describe "mongoid state machine" do
     end
 
     it "should not validate when try transition with wrong state " do
-      for s in @light.class.state_machine.states
-        @light.state = s.name
+      for s in @light.class.state_machines[:default].states.keys
+        @light.state = s
         @light.valid?.should == true
       end
       @light.state = "invalid_one"
@@ -158,18 +70,37 @@ describe "mongoid state machine" do
       expect {validating_light.reset!}.should raise_error Mongoid::Errors::Validations
     end
 
-    #it "should state query method used in a validation condition" do
-      #validating_light = MongoConditionalValidatingTrafficLight.create!
+    it "should state query method used in a validation condition" do
+      validating_light = MongoConditionalValidatingTrafficLight.create!
       #expect {validating_light.reset!}.should raise_error Mongoid::RecordInvalid
-      #validating_light.off?.should == true
-    #end
+      validating_light.off?.should == true
+    end
 
     it "should reload the model when current state resets" do
       @light.reset
       @light.red?.should == true
       @light.update_attribute(:state, 'green')
-      @light.reload.green?.should == false # reloaded state should come from instance variable not from database
-      # because the state can be changed without persist
+      @light.reload.green?.should == true # reloaded state should come from database
+    end
+
+    describe "scopes" do
+      it "should be added for each state" do
+        MongoTrafficLight.should respond_to(:off)
+        MongoTrafficLight.should respond_to(:red)
+      end
+
+      it "should not be added for each state" do
+        #MongoTrafficLightNoScope.should_not respond_to(:off)
+        #MongoTrafficLightNoScope.should_not respond_to(:red)
+      end
+
+      it "should behave like scopes" do
+        3.times { MongoTrafficLight.create(:state => "off") }
+        3.times { MongoTrafficLight.create(:state => "red") }
+        # one was created before
+        MongoTrafficLight.off.count.should == 4
+        MongoTrafficLight.red.count.should == 3
+      end
     end
   end
 
@@ -198,54 +129,5 @@ describe "mongoid state machine" do
       expect { @order.place! }.should_not raise_error
       @order.state.should == "placed"
     end
-
-    it "should set paid_at when moving to paid" do
-      @order = create_order(:placed)
-      @order.pay!
-      @order.reload
-      @order.paid_at.should_not be_nil
-    end
-
-    it "should set prepared_on when moving to prepared" do
-      @order = create_order(:paid)
-      @order.prepare!
-      @order.reload
-      @order.prepared_on.should_not be_nil
-    end
-
-    it "should set dispatched_at when moving to delivered" do
-      @order = create_order(:prepared)
-      @order.deliver!
-      @order.reload
-      @order.dispatched_at.should_not be_nil
-    end
-
-    it "should set cancellation_date when moving to cancelled" do
-      @order = create_order(:placed)
-      @order.cancel!
-      @order.reload
-      @order.cancellation_date.should_not be_nil
-    end
-
-    it "should raise an exception as there is no attribute when moving to reopened" do
-      @order = create_order(:cancelled)
-      expect { @order.re_open! }.should raise_error NoMethodError
-      @order.reload
-    end
-
-    it "should raise an exception when passing an invalid value to timestamp options" do
-      expect {
-        class MongoOrder
-          include Mongoid::Document
-          include Mongoid::EdgeStateMachine
-
-          state_machine do
-            event :replace, timestamp: 1 do
-              transitions :from => :prepared, :to => :placed
-            end
-          end
-        end
-      }.should raise_error ArgumentError
-    end
   end
 end

data/spec/mongoid/samples/order.rb

@@ -0,0 +1,54 @@
+require 'mongoid'
+require 'mongoid/edge-state-machine'
+
+class MongoOrder
+  include Mongoid::Document
+  include Mongoid::EdgeStateMachine
+
+  field :state, :type => String
+  field :order_number, :type => Integer
+  field :paid_at, :type => DateTime
+  field :prepared_on, :type => DateTime
+  field :dispatched_at, :type => DateTime
+  field :cancellation_date, :type => Date
+
+  state_machine do
+    state :opened
+    state :placed
+    state :paid
+    state :prepared
+    state :delivered
+    state :cancelled
+
+    # no timestamp col is being specified here - should be ignored
+    event :place do
+      transition :from => :opened, :to => :placed
+    end
+
+    # should set paid_at timestamp
+    event :pay do
+      transition :from => :placed, :to => :paid
+    end
+
+    # should set prepared_on
+    event :prepare do
+      transition :from => :paid, :to => :prepared
+    end
+
+    # should set dispatched_at
+    event :deliver do
+      transition :from => :prepared, :to => :delivered
+    end
+
+    # should set cancellation_date
+    event :cancel do
+      transition :from => [:placed, :paid, :prepared], :to => :cancelled
+    end
+
+    # should raise an exception as there is no timestamp col
+    event :reopen do
+      transition :from => :cancelled, :to => :opened
+    end
+
+  end
+end

data/spec/mongoid/samples/traffic_light.rb

@@ -0,0 +1,46 @@
+require 'mongoid'
+require 'mongoid/edge-state-machine'
+
+class MongoTrafficLight
+  include Mongoid::Document
+  include Mongoid::EdgeStateMachine
+  field :state
+
+  state_machine do
+    create_scopes true
+    persisted_to :state
+    state :off
+
+    state :red
+    state :green
+    state :yellow
+
+    event :red_on do
+      transition :to => :red, :from => [:yellow]
+    end
+
+    event :green_on do
+      transition :to => :green, :from => [:red]
+    end
+
+    event :yellow_on do
+      transition :to => :yellow, :from => [:green]
+    end
+
+    event :reset do
+      transition :to => :red, :from => [:off]
+    end
+  end
+end
+
+class MongoProtectedTrafficLight < MongoTrafficLight
+  attr_protected :state
+end
+
+class MongoValidatingTrafficLight < MongoTrafficLight
+  validate {|t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
+end
+
+class MongoConditionalValidatingTrafficLight < MongoTrafficLight
+  validates :name, :presence => true, :length  => { :within => 20..40 }, :confirmation => true, :if => :red?
+end

data/spec/non_persistent/non_persistent_helper.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'non_persistent/samples/dice'
+require 'non_persistent/samples/user'
+require 'non_persistent/samples/microwave'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'edge-state-machine'

data/spec/non_persistent/non_persistent_spec.rb

@@ -0,0 +1,80 @@
+require 'non_persistent/non_persistent_helper'
+
+
+describe Dice do
+  before do
+    @dice = Dice.new
+  end
+
+  it "should have a current state equals with the initial state" do
+    @dice.current_state_name.should == :one
+  end
+
+  it "should have an event trigger method" do
+    @dice.should respond_to :roll
+  end
+
+  it "should change state after the event method is called" do
+    @dice.roll
+    @dice.current_state_name.should_not == :one
+  end
+end
+
+
+describe User do
+  before do
+    @user = User.new
+  end
+
+  it "should have a current state equals with the initial state" do
+    @user.current_state_name.should == :pending
+  end
+
+  it "should have an event trigger method" do
+    @user.should respond_to :activate
+  end
+
+  it "should have state verfification methods for each state" do
+    @user.pending?.should == true
+    @user.active?.should_not == true
+    @user.blocked?.should_not == true
+  end
+
+  it "should change state after the event method is called" do
+    @user.activate
+    @user.current_state_name.should == :active
+  end
+end
+
+describe Microwave do
+  before do
+    @microwave = Microwave.new
+  end
+
+  it "should have a current state equals with the initial state" do
+    @microwave.current_state_name(:microwave).should == :unplugged
+  end
+
+  it "should have an event trigger method" do
+    @microwave.should respond_to :plug_in
+  end
+
+  it "should have state verfification methods for each state" do
+    @microwave.unplugged?.should == true
+    @microwave.plugged?.should_not == true
+    @microwave.door_opened?.should_not == true
+    @microwave.door_closed?.should_not == true
+    @microwave.started_in_grill_mode?.should_not == true
+    @microwave.started?.should_not == true
+  end
+
+  it "should change state after the event method is called" do
+    @microwave.plug_in
+    @microwave.current_state_name(:microwave).should == :plugged
+    @microwave.plugged?.should == true
+  end
+
+  it "should execute enter state action" do
+    @microwave.plug_in
+  end
+end

data/spec/non_persistent/samples/dice.rb

@@ -0,0 +1,31 @@
+require 'edge-state-machine'
+
+class Dice
+  include EdgeStateMachine
+
+  state_machine do
+    state :one
+    state :two
+    state :three
+    state :four
+    state :five
+    state :six
+
+    event :roll do
+      transition :from => [:one, :two, :three, :four, :five, :six],
+                 :to => [:one, :two, :three, :four, :five, :six],
+                 :guard => :roll_result,
+                 :on_transition => :display_dice_rolling_animation
+    end
+  end
+
+  def roll_result
+    # return one of the states, except the initial state
+    [:two, :three, :four, :five, :six][Random.rand(4)]
+  end
+
+  def display_dice_rolling_animation
+    # draw the new position of the dice
+    # p 'display dice'
+  end
+end

data/spec/non_persistent/samples/microwave.rb

@@ -0,0 +1,54 @@
+require 'edge-state-machine'
+
+class Microwave
+  include EdgeStateMachine
+
+  state_machine :microwave do  # name should be optional, if the name is not present, it should have a default name
+                               # we give state machines names, so we can pun many machines inside a class
+    initial_state :unplugged # initial state should be optional, if the initial state is not present, the initial state will be the first defined state
+
+    state :plugged
+
+    state :unplugged
+
+    state :door_opened do
+      enter :light_on            # enter should be executed on entering the state
+      exit  :light_off           # exit method should be executed on exiting the state
+    end
+
+    state :door_closed
+
+    state :started_in_grill_mode do
+      enter lambda { |t| p "Entering hate" }   # should have support for Procs
+      exit  :grill_off
+    end
+
+    state :started do
+      enter :microwaves_on
+      exit  :microwaves_off
+    end
+
+    event :plug_in do
+      transition :from => :unplugged, :to => :plugged
+    end
+
+    event :open_door do
+      transition :from => :plugged, :to => :door_opened
+    end
+
+    event :close_door do
+      transition :from => :door_opened, :to => :door_closed, :on_transition => :put_food_in_the_microwave # we can put many actions in an Array for the on_transition parameter
+    end
+
+    event :start do
+      transition :from => :door_closed, :to => [:started, :started_in_grill_mode], :on_transition => :start_spinning_the_food, :guard => :grill_button_pressed?    # the method grill_button_pressed? should choose the next state
+    end
+
+    event :stop do
+      transition :from => [:started, :started_in_grill_mode], :to => :door_closed
+    end
+  end
+
+  def light_on
+  end
+end

data/spec/non_persistent/samples/user.rb

@@ -0,0 +1,23 @@
+require 'edge-state-machine'
+
+class User
+  include EdgeStateMachine
+
+  state_machine do
+    state :pending # first one is initial state
+    state :active
+    state :blocked # the user in this state can't sign in
+
+    event :activate do
+      transition :from => [:pending], :to => :active, :on_transition => :do_activate
+    end
+
+    event :block do
+      transition :from => [:pending, :active], :to => :blocked
+    end
+  end
+
+  def do_activate
+    # p 'do activate'
+  end
+end

data/spec/state_spec.rb

@@ -16,11 +16,11 @@ class Car
     state :driving
 
     event :turn_key do
-      transitions :from => :parked, :to => :running, :on_transition => :start_engine
+      transition :from => :parked, :to => :running, :on_transition => :start_engine
     end
 
     event :start_driving do
-      transitions :from => :parked, :to => :driving, :on_transition => [:start_engine, :loosen_handbrake, :push_gas_pedal]
+      transition :from => :parked, :to => :driving, :on_transition => [:start_engine, :loosen_handbrake, :push_gas_pedal]
     end
   end
 
@@ -33,7 +33,7 @@ class Car
 end
 
 def new_state(options={})
-  EdgeStateMachine::State.new(@state_name, @options.merge(options))
+  EdgeStateMachine::State.new(@state_name)
 end
 
 describe EdgeStateMachine::State do
@@ -41,7 +41,6 @@ describe EdgeStateMachine::State do
   before do
     @state_name = :astate
     @machine = StateTestSubject.state_machine
-    @options = { :crazy_custom_key => "key", :machine => @machine }
   end
 
   it "should set the name" do
@@ -52,13 +51,14 @@ describe EdgeStateMachine::State do
     new_state.display_name.should == "Astate"
   end
 
-  it "should set the display_name from options" do
-    new_state(:display => "A State").display_name.should == "A State"
+  it "should set the display_name from method" do
+    state = new_state
+    state.use_display_name('A State')
+    state.display_name.should == 'A State'
   end
 
   it "should set the options and expose them as options" do
-    @options.delete(:machine)
-    new_state.options.should == @options
+    new_state.options.should_not == nil
   end
 
   it "should be equal to a symbol of the same name" do
@@ -70,27 +70,32 @@ describe EdgeStateMachine::State do
   end
 
   it "should send a message to the record for an action if the action is present as a symbol" do
-    state = new_state(:entering => :foo)
+    state = new_state
+    state.enter :foo
+    
     record = mock
     record.should_receive(:foo)
-    state.call_action(:entering, record)
+    
+    state.execute_action(:enter, record)
   end
 
   it "should send a message to the record for an action if the action is present as a string" do
-    state = new_state(:entering => "foo")
+    state = new_state
+    state.enter "foo"
 
     record = mock
     record.should_receive(:foo)
 
-    state.call_action(:entering, record)
+    state.execute_action(:enter, record)
   end
 
   it "should call a proc, passing in the record for an action if the action is present" do
-    state = new_state(:entering => Proc.new {|r| r.foobar})
+    state = new_state
+    state.exit Proc.new {|r| r.foobar}
 
     record = mock
     record.should_receive(:foobar)
 
-    state.call_action(:entering, record)
+    state.execute_action(:exit, record)
   end
 end