edge-state-machine 0.0.2 → 0.0.3

data/lib/mongoid/edge-state-machine.rb

@@ -5,28 +5,73 @@ module Mongoid
     included do
       include ::EdgeStateMachine
       after_initialize :set_initial_state
-      validates_presence_of :state
+      validate :state_variables_presence
       validate :state_inclusion
     end
 
+    # The optional options argument is passed to find when reloading so you may
+    # do e.g. record.reload(:lock => true) to reload the same record with an
+    # exclusive row lock.
+    def reload
+      super.tap do
+        @current_states = {}
+      end
+    end
+
     protected
 
-    def write_state(state_machine, state)
-      self.state = state.to_s
-      save!
+    def load_from_persistence(machine_name)
+      machine = self.class.state_machines[machine_name]
+      send machine.persisted_variable_name.to_s
     end
 
-    def read_state(state_machine)
-      self.state.to_sym
+    def save_to_persistence(new_state, machine_name, options = {})
+      machine = self.class.state_machines[machine_name]
+      send("#{machine.persisted_variable_name}=".to_sym, new_state)
+      save! if options[:save]
     end
 
     def set_initial_state
-      self.state ||= self.class.state_machine.initial_state.to_s
+      # set the initial state for each state machine in this class
+      self.class.state_machines.keys.each do |machine_name|
+        machine = self.class.state_machines[machine_name]
+
+        if persisted_variable_value(machine.persisted_variable_name).blank?
+          if load_from_persistence(machine_name)
+            send("#{machine.persisted_variable_name}=".to_sym, load_from_persistence(machine_name))
+          else
+            send("#{machine.persisted_variable_name}=".to_sym, machine.initial_state_name)
+          end
+        end
+      end
+    end
+
+    def persisted_variable_value(name)
+      send(name.to_s)
+    end
+
+    def state_variables_presence
+      # validate that state is in the right set of values
+      self.class.state_machines.keys.each do |machine_name|
+        machine = self.class.state_machines[machine_name]
+        validates_presence_of machine.persisted_variable_name.to_sym
+      end
     end
 
     def state_inclusion
-      unless self.class.state_machine.states.map{|s| s.name.to_s }.include?(self.state.to_s)
-        self.errors.add(:state, :inclusion, :value => self.state)
+      # validate that state is in the right set of values
+      self.class.state_machines.keys.each do |machine_name|
+        machine = self.class.state_machines[machine_name]
+        unless machine.states.keys.include?(persisted_variable_value(machine.persisted_variable_name).to_sym)
+          self.errors.add(machine.persisted_variable_name.to_sym, :inclusion, :value => persisted_variable_value(machine.persisted_variable_name))
+        end
+      end
+    end
+
+    module ClassMethods
+      def add_scope(state, machine_name)
+        machine = state_machines[machine_name]
+        scope state.name, where(machine.persisted_variable_name.to_sym => state.name.to_s)
       end
     end
   end

data/spec/active_record/active_record_helper.rb

@@ -3,6 +3,8 @@ require 'active_record'
 require 'active_support/core_ext/module/aliasing'
 require 'active_record/migrations/create_orders'
 require 'active_record/migrations/create_traffic_lights'
+require 'active_record/samples/traffic_light'
+require 'active_record/samples/order'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/spec/active_record/active_record_spec.rb

@@ -1,92 +1,5 @@
 require 'active_record/active_record_helper'
 
-ActiveRecord::Base.establish_connection(:adapter  => "sqlite3", :database => ":memory:")
-
-class TrafficLight < ActiveRecord::Base
-  include ActiveRecord::EdgeStateMachine
-
-  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 ProtectedTrafficLight < TrafficLight
-  attr_protected :state
-end
-
-class ValidatingTrafficLight < TrafficLight
-  validate {|t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
-end
-
-class ConditionalValidatingTrafficLight < TrafficLight
-  validates :name, :presence => true, :length  => { :within => 20..40 }, :confirmation => true, :if => :red?
-end
-
-
-class Order < ActiveRecord::Base
-  include ActiveRecord::EdgeStateMachine
-
-  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 "active record state machine" do
 
   context "existing active record" do
@@ -126,8 +39,14 @@ describe "active record state machine" do
       @light.state.should == "red"
     end
 
+    it "should initialize the current state when loaded from database" do
+      @light.reset!
+      loaded_light = TrafficLight.find_by_id(@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
 
@@ -140,8 +59,8 @@ describe "active record 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"
@@ -151,21 +70,42 @@ describe "active record state machine" do
     it "should raise exception when model validation fails on transition" do
       validating_light = ValidatingTrafficLight.create!
       expect {validating_light.reset!}.should raise_error ActiveRecord::RecordInvalid
+      validating_light.red?.should == false
       validating_light.off?.should == true
     end
 
-    #it "should state query method used in a validation condition" do
-      #validating_light = ConditionalValidatingTrafficLight.create!
+    it "should state query method used in a validation condition" do
+      validating_light = ConditionalValidatingTrafficLight.create!
       #expect {validating_light.reset!}.should raise_error ActiveRecord::RecordInvalid
-      #validating_light.off?.should == true
-    #end
+      validating_light.off?.should == true
+      validating_light.red?.should == false
+    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
+        TrafficLight.should respond_to(:off)
+        TrafficLight.should respond_to(:red)
+      end
+
+      it "should not be added for each state" do
+        #TrafficLightNoScope.should_not respond_to(:off)
+        #TrafficLightNoScope.should_not respond_to(:red)
+      end
+
+      it "should behave like scopes" do
+        3.times { TrafficLight.create(:state => "off") }
+        3.times { TrafficLight.create(:state => "red") }
+        # one was created before
+        TrafficLight.off.count.should == 4
+        TrafficLight.red.count.should == 3
+      end
     end
   end
 
@@ -196,53 +136,5 @@ describe "active record 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 Order < ActiveRecord::Base
-          include ActiveRecord::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/active_record/samples/order.rb

@@ -0,0 +1,47 @@
+require 'active_record'
+require 'active_record/edge-state-machine'
+
+ActiveRecord::Base.establish_connection(:adapter  => "sqlite3", :database => ":memory:")
+
+class Order < ActiveRecord::Base
+  include ActiveRecord::EdgeStateMachine
+
+  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/active_record/samples/traffic_light.rb

@@ -0,0 +1,46 @@
+require 'active_record'
+require 'active_record/edge-state-machine'
+
+ActiveRecord::Base.establish_connection(:adapter  => "sqlite3", :database => ":memory:")
+
+class TrafficLight < ActiveRecord::Base
+  include ActiveRecord::EdgeStateMachine
+
+  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 ProtectedTrafficLight < TrafficLight
+  attr_protected :state
+end
+
+class ValidatingTrafficLight < TrafficLight
+  validate {|t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
+end
+
+class ConditionalValidatingTrafficLight < TrafficLight
+  validate :name, :presence => true, :length  => { :within => 20..40 }, :confirmation => true, :if => :red?
+end

data/spec/event_spec.rb

@@ -9,7 +9,7 @@ class ArgumentsTestSubject
     state :opened
 
     event :open do
-      transitions :from => :initial, :to => :opened, :on_transition => :update_date
+      transition :from => :initial, :to => :opened, :on_transition => :update_date
     end
   end
 
@@ -19,8 +19,8 @@ class ArgumentsTestSubject
 end
 
 def new_event
-  @event = EdgeStateMachine::Event.new(nil, @state_name, {:success => @success}) do
-    transitions :to => :closed, :from => [:open, :received]
+  @event = EdgeStateMachine::Event.new(@state_name, nil) do
+    transition :to => :closed, :from => [:open, :received]
   end
 end
 
@@ -29,8 +29,8 @@ describe EdgeStateMachine::Event do
   before do
     @state_name = :close_order
     @success = :success_callback
-    @event = EdgeStateMachine::Event.new(nil, @state_name, {:success => @success}) do
-      transitions :to => :closed, :from => [:open, :received]
+    @event = EdgeStateMachine::Event.new(@state_name, nil) do
+      transition :to => :closed, :from => [:open, :received]
     end
   end
 
@@ -38,13 +38,8 @@ describe EdgeStateMachine::Event do
     @state_name.should == @event.name
   end
 
-  it "should set the success option" do
-    @success.should == @event.success
-  end
-
   it "should create Transitions" do
-    EdgeStateMachine::Transition.should_receive(:new).with(:to => :closed, :from => :open)
-    EdgeStateMachine::Transition.should_receive(:new).with(:to => :closed, :from => :received)
+    EdgeStateMachine::Transition.should_receive(:new).with(:to => :closed, :from => [:open, :received])
     new_event
   end
 
@@ -52,25 +47,22 @@ describe EdgeStateMachine::Event do
     it "should pass arguments to transition method" do
       subject = ArgumentsTestSubject.new
       subject.current_state.should == :initial
-      subject.open!(Date.strptime('2001-02-03', '%Y-%m-%d'))
+      subject.open!
       subject.current_state.should == :opened
-      subject.date.should == Date.strptime('2001-02-03', '%Y-%m-%d')
     end
   end
 
   describe "events being fired" do
-    it "should raise an EdgeStateMachine::InvalidTransition error if the transitions are empty" do
-      event = EdgeStateMachine::Event.new(nil, :event)
-      expect {event.fire(nil)}.should raise_error EdgeStateMachine::InvalidTransition
+    before do
+      @machine = mock
+      @machine.stub!(:name).and_return(:default)
     end
 
-    it "should return the state of the first matching transition it finds" do
-      event = EdgeStateMachine::Event.new(nil, :event) do
-        transitions :to => :closed, :from => [:open, :received]
-      end
+    it "should raise an EdgeStateMachine::NoTransitionFound error if the transitions are empty" do
+      event = EdgeStateMachine::Event.new(:event, @machine)
       obj = mock
       obj.stub!(:current_state).and_return(:open)
-      event.fire(obj).should == :closed
+      expect {event.fire(obj)}.should raise_error EdgeStateMachine::NoTransitionFound
     end
   end
 end

data/spec/machine_spec.rb

@@ -8,17 +8,20 @@ class MachineTestSubject
     state :closed
   end
 
-  state_machine :initial => :foo do
+  state_machine do
+    initial_state :open
+
     event :shutdown do
-      transitions :from => :open, :to => :closed
+      transition :from => :open, :to => :closed
     end
 
     event :timeout do
-      transitions :from => :open, :to => :closed
+      transition :from => :open, :to => :closed
     end
   end
 
-  state_machine :extra, :initial => :bar do
+  state_machine :extra do
+    initial_state :bar
   end
 end
 
@@ -28,17 +31,11 @@ describe EdgeStateMachine::Machine do
     MachineTestSubject.state_machines.size.should == 2
   end
 
-  it "should set #initial_state from :initial option" do
-    MachineTestSubject.state_machine(:extra).initial_state.should == :bar
-  end
-
-  it "should accesse non-default state machine" do
-    MachineTestSubject.state_machine(:extra).class.should == EdgeStateMachine::Machine
+  it "should set #initial_state_name from initial_state method" do
+    MachineTestSubject.state_machines[:extra].initial_state_name.should == :bar
   end
 
-  it "should find event for given state" do
-    events = MachineTestSubject.state_machine.events_for(:open)
-    events.should be_include(:shutdown)
-    events.should be_include(:timeout)
+  it "should access non-default state machine" do
+    MachineTestSubject.state_machines[:extra].class.should == EdgeStateMachine::Machine
   end
 end

data/spec/mongoid/mongoid_helper.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 require 'mongoid'
+require 'mongoid/samples/traffic_light'
+require 'mongoid/samples/order'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'mongoid/edge-state-machine'
 
 Mongoid.configure do |config|
   config.master = Mongo::Connection.new.db('edge_state_machine_test')
   config.allow_dynamic_fields = false
-end
-
+end