yasm 0.0.3 → 0.0.6

data/features/step_definitions/action_steps.rb

@@ -0,0 +1,31 @@
+Given /^a context$/ do
+  class ActionFeatureContext
+    include Yasm::Context
+
+    start :action_feature_state_1
+  end
+
+  class ActionFeatureState1
+    include Yasm::State
+  end
+
+  class ActionFeatureState2
+    include Yasm::State
+  end
+
+  @context = ActionFeatureContext.new
+  @context.state.value.class.should == ActionFeatureState1
+end
+
+When /^I apply an action to it that triggers a state transition$/ do
+  class TriggerActionFeatureState2
+    include Yasm::Action
+
+    triggers :action_feature_state_2
+  end
+  @context.do! TriggerActionFeatureState2
+end
+
+Then /^the state should transition appropriately$/ do
+  @context.state.value.class.should == ActionFeatureState2
+end

data/features/step_definitions/final_state_steps.rb

@@ -0,0 +1,34 @@
+Given /^a state that I intend to declare final$/ do
+  class FinalState; include Yasm::State; end
+  FinalState.final?.should be_false
+end
+
+When /^I declare it final$/ do
+  FinalState.final!
+end
+
+Then /^it should return true when asked if it's a FINAL state$/ do
+  FinalState.final?.should be_true
+end
+
+Given /^a final state$/ do
+  class ContextWithFinalState
+    include Yasm::Context
+    start :final_state
+  end
+
+  class FinalState
+    include Yasm::State
+    final!
+  end
+  @context = ContextWithFinalState.new
+end
+
+When /^I attempt to apply an action to it$/ do
+  class ImpossibleAction; include Yasm::Action; end
+  @apply_action = proc {@context.do! ImpossibleAction}
+end
+
+Then /^I should get an exception$/ do
+  @apply_action.should raise_exception(Yasm::FinalStateException)
+end

data/features/step_definitions/persistence/couchrest_model_persistence_steps.rb

@@ -0,0 +1,85 @@
+Given /^a class that inherits from CouchRest::Model::Base$/ do
+  class TestYasmCouchPersistence < CouchRest::Model::Base
+  end
+end
+
+When /^I mix Yasm::Context into it$/ do
+  class TestYasmCouchPersistence
+    include Yasm::Context
+  end
+end
+
+Then /^Yasm::Persistence::CouchRest::Model should be autoincluded as well$/ do
+  TestYasmCouchPersistence.ancestors.should be_include(Yasm::Persistence::CouchRest::Model)
+end
+
+Given /^a couchrest model context$/ do
+  class CouchContext < CouchRest::Model::Base
+    use_database YASM_COUCH_DB
+    include Yasm::Context
+
+    start :couch_state1
+  end
+  class CouchState1
+    include Yasm::State
+  end
+  class CouchState2
+    include Yasm::State
+  end
+  class GoToState2
+    include Yasm::Action
+    triggers :couch_state2
+  end
+  @couch_context = CouchContext.new
+end
+
+When /^I save that context to CouchDB$/ do
+  @couch_context.do! GoToState2
+  @state_start_time = @couch_context.state.value.instantiated_at
+  @couch_context.save
+end
+
+Then /^the states should be saved in the document$/ do
+  @doc = YASM_COUCH_DB.get @couch_context.id
+  @doc["yasm"].should_not be_nil
+  @doc["yasm"]["states"][Yasm::Context::ANONYMOUS_STATE.to_s].should_not be_nil
+  @doc["yasm"]["states"][Yasm::Context::ANONYMOUS_STATE.to_s]["class"].should == "CouchState2"
+  Time.parse(@doc["yasm"]["states"][Yasm::Context::ANONYMOUS_STATE.to_s]["instantiated_at"]).to_s.should == @state_start_time.to_s
+end
+
+Given /^a couchrest model context with state saved in the database$/ do
+  class CouchContext < CouchRest::Model::Base
+    include Yasm::Context
+
+    start :couch_state1
+  end
+  class CouchState1; include Yasm::State; end
+  class CouchState2
+    include Yasm::State
+
+    maximum 9.minutes, :action => :go_to_state3
+  end
+  class CouchState3
+    include Yasm::State
+  end
+  class GoToState2; include Yasm::Action; triggers :couch_state2; end
+  class GoToState3; include Yasm::Action; triggers :couch_state3; end
+  @couch_context = CouchContext.new 
+  @couch_context.do! GoToState2
+  @state_start_time = @couch_context.state.value.instantiated_at
+  @couch_context.save
+end
+
+When /^I load that context$/ do
+  ten_minutes_from_now = 10.minutes.from_now
+  Time.stub(:now).and_return ten_minutes_from_now
+  @couch_context = CouchContext.find @couch_context.id
+end
+
+Then /^the states should be restored$/ do
+  @couch_context.state.value.class.should == CouchState3
+end
+
+Then /^the states should be fast forwarded$/ do
+  @couch_context.state.value.class.should == CouchState3
+end

data/features/step_definitions/state_with_limited_actions_steps.rb

@@ -0,0 +1,27 @@
+Given /^a state$/ do
+  class StateWithLimitedActions
+    include Yasm::State
+  end
+end
+
+When /^I declare that only certain actions can be applied to it$/ do
+  StateWithLimitedActions.actions :limited_action1, :limited_action2
+end
+
+Then /^those actions should be stored on the state class$/ do
+  StateWithLimitedActions.allowed_actions.should == [:limited_action1, :limited_action2]
+end
+
+Given /^a state with limited actions$/ do
+  StateWithLimitedActions.actions :limited_action1, :limited_action2
+end
+
+Then /^I should be able to determine whether a given action is valid for a given state$/ do
+  class LimitedAction1; include Yasm::Action; end
+  class LimitedAction2; include Yasm::Action; end
+  class LimitedAction3; include Yasm::Action; end
+
+  StateWithLimitedActions.is_allowed?(LimitedAction1).should be_true
+  StateWithLimitedActions.is_allowed?(LimitedAction2).should be_true
+  StateWithLimitedActions.is_allowed?(LimitedAction3).should be_false
+end

data/features/step_definitions/states_with_time_limits_steps.rb

@@ -0,0 +1,147 @@
+Given /^a state that I intend to declare a minimum time limit on$/ do
+  class StateWithMinimumTimeLimit
+    include Yasm::State
+  end
+  StateWithMinimumTimeLimit.minimum_duration.should be_nil
+end
+
+When /^I declare a minimum time limit on it$/ do
+  StateWithMinimumTimeLimit.minimum 10.minutes
+end
+
+Then /^it should store that time limit on the state class$/ do
+  StateWithMinimumTimeLimit.minimum_duration.should == 10.minutes
+end
+
+Given /^a state that has a minimum time limit$/ do
+  class ContextWithStateWithMinimumTimeLimit
+    include Yasm::Context
+    start :state_with_minimum_time_limit
+  end
+
+  class StateWithMinimumTimeLimit
+    include Yasm::State
+    minimum 10.minutes
+  end
+
+  @context = ContextWithStateWithMinimumTimeLimit.new
+end
+
+When /^I apply an action to that state before its minimum time limit has been reached$/ do
+  class ActionOnStateWithMinimumTimeLimit
+    include Yasm::Action
+  end
+  
+  @apply_action = proc {@context.do! ActionOnStateWithMinimumTimeLimit}
+end
+
+Then /^I should get a minimum time limit exception$/ do
+  @apply_action.should raise_exception(Yasm::TimeLimitNotYetReached)
+end
+
+When /^I apply an action to that state after its minimum time limit has been reached$/ do
+  @apply_action = proc {
+    ten_minutes_from_now = 10.minutes.from_now
+    Time.stub(:now).and_return ten_minutes_from_now
+    @context.do! ActionOnStateWithMinimumTimeLimit
+  }
+end
+
+Then /^I should not get a minimum time limit exception$/ do
+  @apply_action.should_not raise_exception 
+end
+
+Given /^a state that I intend to declare a maximum time limit on$/ do
+  class StateWithMaxTimeLimit
+    include Yasm::State
+  end
+end
+
+When /^I declare a maximum time limit on it without an action$/ do
+  @declaration = proc {
+    StateWithMaxTimeLimit.maximum 10.minutes
+  }
+end
+
+Then /^it should raise an argument error exception$/ do
+  @declaration.should raise_error(ArgumentError)
+end
+
+When /^I declare a maximum time limit on it with an action$/ do
+  @declaration = proc {
+    StateWithMaxTimeLimit.maximum 10.minutes, :action => :max_time_limit_action
+  }
+  class MaxTimeLimitAction; include Yasm::Action; end
+end
+
+Then /^it should store that maximum time limit and action on the state class$/ do
+  @declaration.should_not raise_error
+  StateWithMaxTimeLimit.maximum_duration.should == 10.minutes
+  StateWithMaxTimeLimit.maximum_duration_action.should == MaxTimeLimitAction
+end
+
+Given /^a context with the potential for a max time limit dominoe effect$/ do
+  class DominoContext
+    include Yasm::Context
+
+    start :domino1
+  end
+  
+  class Domino1
+    include Yasm::State
+    
+    actions :trigger_domino2
+    maximum 10.minutes, :action => :trigger_domino2
+  end
+
+  class TriggerDomino2
+    include Yasm::Action
+
+    triggers :domino2
+  end
+
+  class Domino2
+    include Yasm::State
+
+    maximum 10.minutes, :action => :trigger_domino3
+  end
+
+  class TriggerDomino3
+    include Yasm::Action
+
+    triggers :domino3
+  end
+
+  class Domino3
+    include Yasm::State
+  end
+
+  class TriggerDomino4
+    include Yasm::Action
+
+    triggers :domino4
+  end
+
+  class Domino4
+    include Yasm::State
+  end
+end
+
+When /^I wait long enough to cause the dominoe effect$/ do
+  @wait = proc {
+    @context = DominoContext.new
+    @context.state.value
+    thirty_minutes_from_now = 30.minutes.from_now
+    Time.stub(:now).and_return thirty_minutes_from_now
+  }
+end
+
+Then /^the dominoe effect should occur when I ask for the state$/ do
+  @wait.call
+  @context.state.value.class.should == Domino3
+end
+
+Then /^the dominoe effect should occur when I attempt to apply an action to the context$/ do
+  @context.do! TriggerDomino4
+  @context.state.value.class.should == Domino4
+end

data/features/support/setup.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift './lib'
+require 'yasm'
+require 'rspec'
+require 'rspec/mocks/standalone'
+require 'couchrest_model'
+
+COUCHDB_SERVER = CouchRest.new "http://admin:password@localhost:5984"
+YASM_COUCH_DB = COUCHDB_SERVER.database!('yasm_test')
+COUCHDB_SERVER.default_database = 'yasm_test'
+
+Before('@couch') do
+  YASM_COUCH_DB.recreate!
+end

data/lib/yasm.rb

@@ -9,4 +9,6 @@ require 'yasm/action'
 require 'yasm/context/anonymous_state_identifier'
 require 'yasm/context/state_configuration'
 require 'yasm/context/state_container'
+require 'yasm/context/state_configuration/action_hook'
 require 'yasm/context'
+require 'yasm/persistence'

data/lib/yasm/context.rb

@@ -2,23 +2,32 @@ module Yasm
   module Context
     def self.included(base)
       base.extend ClassMethods
+      if defined?(CouchRest) and defined?(CouchRest::Model) and base.ancestors.include?(CouchRest::Model::Base) and !base.ancestors.include?(Yasm::Persistence::CouchRest::Model)
+        base.send :include, Yasm::Persistence::CouchRest::Model
+      end
     end
 
     module ClassMethods
+      def after_action(method, options={})
+        state_configuration(ANONYMOUS_STATE).after_action method, options
+      end
+
+      def before_action(method, options={})
+        state_configuration(ANONYMOUS_STATE).before_action method, options
+      end
+      
       # for a simple, anonymous state 
       def start(state)
-        state_configurations[ANONYMOUS_STATE] = StateConfiguration.new
-        state_configurations[ANONYMOUS_STATE].start state
+        state_configuration(ANONYMOUS_STATE).start state
       end
 
       # for a named state
       def state(name, &block)
         raise ArgumentError, "The state name must respond to `to_sym`" unless name.respond_to?(:to_sym)
         name = name.to_sym
-        state_configurations[name] = StateConfiguration.new 
-        state_configurations[name].instance_eval &block
+        state_configuration(name).instance_eval &block
         
-        raise "You must provide a start state for #{name}" unless state_configurations[name].start_state
+        raise "You must provide a start state for #{name}" unless state_configuration(name).start_state
 
         define_method(name) { state_container name }
       end
@@ -27,6 +36,11 @@ module Yasm
       def state_configurations
         @state_configurations ||= {}
       end
+
+      private
+      def state_configuration(name)
+        state_configurations[name] ||= StateConfiguration.new
+      end
     end
 
     def do!(*actions)
@@ -38,6 +52,10 @@ module Yasm
       state_container ANONYMOUS_STATE
     end
 
+    def fast_forward
+      self.class.state_configurations.keys.each { |state_name| state_container(state_name).value }
+    end
+
     private
     def state_containers
       @state_containers ||= {}
@@ -45,7 +63,7 @@ module Yasm
     
     def state_container(id)
       unless state_containers[id]
-        state_containers[id] = StateContainer.new :context => self 
+        state_containers[id] = StateContainer.new :context => self, :name => id 
         Yasm::Manager.change_state :to => self.class.state_configurations[id].start_state, :on => state_containers[id]
       end
 

data/lib/yasm/context/state_configuration.rb

@@ -1,15 +1,25 @@
 module Yasm
   module Context
     class StateConfiguration
-      attr_reader :start_state
-
+      attr_reader :start_state, :after_actions, :before_actions
+      
       def initialize(start_state = nil)
         @start_state = start_state
+        @after_actions = []
+        @before_actions = []
       end
 
       def start(state)
         @start_state = state
       end
+
+      def after_action(method, options={})
+        @after_actions << ActionHook.new(method, options)
+      end
+
+      def before_action(method, options={})
+        @before_actions << ActionHook.new(method, options)
+      end
     end
   end
 end