yasm 0.0.3 → 0.0.6

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/
+*.sw?
+.rvmrc
+Gemfile.lock
+.bundle/
+*.gem

data/CHANGELOG

@@ -0,0 +1,10 @@
+v0.0.5 
+  -- feature: before_action and after_action callbacks on state containers (see README).
+
+v0.0.4
+  -- feature: couchrest_model persistence (see README). 
+
+v0.0.2
+  
+  -- feature: minimum/maximum time limits on states. (see the `State Timers` section in the README).
+  -- feature: exceptions are now subclassed, so that you can easily catch them. 

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/PUBLIC_DOMAIN

@@ -0,0 +1,103 @@
+This software is PUBLIC DOMAIN
+
+
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;;iiii;;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;ijffffffffffffffffji;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;iffffffffffffffffffffffffffi;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, iffffffffffffffffffffffffffffffi ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,ijffffffffffffffffffffffffffffffffffji,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,iffffffffffffffffffffffffffffffffffffffffi,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,jffffffffffffffffffffffffffffffffffffffffffffj,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,tfffffffffffffffffffffffffffffffffffffffffffffft,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,;ffffffffffffffffffffffffffffffffffffffffffffffffff;,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,ffffffffffffffffffffffjt;;,,;;tjffffffffffffffffffffff,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,;fffffffffffffffffft:                :tffffffffffffffffff;,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,jfffffffffffffffft.                    .tffffffffffffffffj,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,ifffffffffffffffi:                          :ifffffffffffffffi,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,tffffffffffffffi                                ifffffffffffffft,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,ifffffffffffff,                                    ,fffffffffffffi,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,fffffffffffffi                                      ifffffffffffff,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,;jffffffffffff                                          ffffffffffffj;,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,ffffffffffff:                                          jffffffffffffff,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,ffffffffffff.                                          jffffffffffffffff,,,,,,,,,,,,,,
+,,,,,,,,,,,,,;ffffffffffft                                          :fffffffffffffffff;,,,,,,,,,,,,,
+,,,,,,,,,,,,,ffffffffffft                    ,tfffffft;            jfffffffffffffffffff,,,,,,,,,,,,,
+,,,,,,,,,,,,tffffffffff.                 ;ffffffffffffffff;       jfffffffffffffffffffft,,,,,,,,,,,,
+,,,,,,,,,,,jffffffffff:               ,ffffffffffffffffffffff,   jffffffffffffffffffffffj,,,,,,,,,,,
+,,,,,,,,,,,fffffffffff               :ffffffffffffffffffffffff: :ffffffffffffffffffffffff,,,,,,,,,,,
+,,,,,,,,,,iffffffffff              ,jfffffffffffffffffffffffff jfffffffffffffffffffffffffi,,,,,,,,,,
+,,,,,,,,,,ffffffffffi             tffffffffffffffffffffffffff jfffffffffffffff iffffffffff,,,,,,,,,,
+,,,,,,,,,ifffffffff,             jfffffffffffffffffffffffff, jfffffffffffffff   ,fffffffffi,,,,,,,,,
+,,,,,,,,,jfffffffff             :ffffffffffffffffffffffffff :fffffffffffffff;    fffffffffj,,,,,,,,,
+,,,,,,,, fffffffffi            jffffffffffffffffffffffffff jfffffffffffffff      ifffffffff ,,,,,,,,
+,,,,,,,,ifffffffff            tffffffffffffffffffffffffff jfffffffffffffff        fffffffffi,,,,,,,,
+,,,,,,,;fffffffffi           :fffffffffffffffffffffffff, jfffffffffffffff         ifffffffff;,,,,,,,
+,,,,,,,ifffffffff:           jfffffffffffffffffffffffff :fffffffffffffff;         :fffffffffi,,,,,,,
+,,,,,,,ffffffffff           :fffffffffffffffffffffffff jfffffffffffffff            ffffffffff,,,,,,,
+,,,,,,,ffffffffft          ,fffffffffffffffff;        jfffffffffffffff t,          tfffffffff,,,,,,,
+,,,,,,;fffffffff           ffffffffffffffff          jfffffffffffffff tff           fffffffff;,,,,,,
+,,,,,,ifffffffft           fffffffffffffff,         :fffffffffffffff;.fff           tffffffffi,,,,,,
+,,,,,,jffffffff:          ;ffffffffffffff.         jfffffffffffffff .ffff;          :ffffffffj,,,,,,
+,,,,,,fffffffff           ffffffffffffff,         jfffffffffffffff tffffff           fffffffff,,,,,,
+,,,,,,fffffffff           fffffffffffff          jfffffffffffffff tfffffff           fffffffff,,,,,,
+,,,,,,fffffffff           fffffffffffff         :fffffffffffffff; ........           fffffffff,,,,,,
+,,,,,;ffffffffj          ,ffffffffffff;        jfffffffffffffff                      jffffffff;,,,,,
+,,,,,;ffffffffi          tffffffffffff        jfffffffffffffff                       iffffffff;,,,,,
+,,,,,;ffffffff;          fffffffffffff       jfffffffffffffff                        ;ffffffff;,,,,,
+,,,,,;ffffffff;          fffffffffffff      :fffffffffffffff;                        ;ffffffff;,,,,,
+,,,,,iffffffff,          fffffffffffff     jfffffffffffffff                          ,ffffffffi,,,,,
+,,,,,iffffffff,          fffffffffffff    jfffffffffffffff                           ,ffffffffi,,,,,
+,,,,,;ffffffff;          fffffffffffff   jfffffffffffffff                            ;ffffffff;,,,,,
+,,,,,;ffffffff;          fffffffffffff  :fffffffffffffff;                            ;ffffffff;,,,,,
+,,,,,;ffffffffi          tffffffffffff jfffffffffffffff                              iffffffff;,,,,,
+,,,,,;ffffffffj          ,fffffffffff jfffffffffffffff                               jffffffff;,,,,,
+,,,,,,fffffffff           fffffffff, jfffffffffffffff        jjjjjjjjjjjjj           fffffffff,,,,,,
+,,,,,,fffffffff           fffffffff :fffffffffffffff;       .fffffffffffff           fffffffff,,,,,,
+,,,,,,fffffffff           ffffffff jfffffffffffffff        ,ffffffffffffff           fffffffff,,,,,,
+,,,,,,jffffffff:          ;ffffff jfffffffffffffff        .ffffffffffffff;          :ffffffffj,,,,,,
+,,,,,,ifffffffft           ffff, jfffffffffffffff        ,fffffffffffffff           tffffffffi,,,,,,
+,,,,,,;fffffffff           ffff :fffffffffffffff;        ffffffffffffffff           fffffffff;,,,,,,
+,,,,,,,ffffffffft          ,ff jfffffffffffffff       ifffffffffffffffff,          tfffffffff,,,,,,,
+,,,,,,,ffffffffff           : jfffffffffffffff tfffffffffffffffffffffff:           ffffffffff,,,,,,,
+,,,,,,,ifffffffff:           jfffffffffffffff tfffffffffffffffffffffffj           :fffffffffi,,,,,,,
+,,,,,,,;fffffffffi          :fffffffffffffff;.ffffffffffffffffffffffff:           ifffffffff;,,,,,,,
+,,,,,,,,ifffffffff         jfffffffffffffff .fffffffffffffffffffffffft            fffffffffi,,,,,,,,
+,,,,,,,, fffffffffi       jfffffffffffffff tffffffffffffffffffffffffj            ifffffffff ,,,,,,,,
+,,,,,,,,,jfffffffff      jfffffffffffffff tffffffffffffffffffffffff:             fffffffffj,,,,,,,,,
+,,,,,,,,,ifffffffff,    :fffffffffffffff;.ffffffffffffffffffffffffj             ,fffffffffi,,,,,,,,,
+,,,,,,,,,,ffffffffffi  jfffffffffffffff .fffffffffffffffffffffffft             iffffffffff,,,,,,,,,,
+,,,,,,,,,,iffffffffff jfffffffffffffff tfffffffffffffffffffffffj,              ffffffffffi,,,,,,,,,,
+,,,,,,,,,,,ffffffffffffffffffffffffff tfffffffffffffffffffffff:               fffffffffff,,,,,,,,,,,
+,,,,,,,,,,,jffffffffffffffffffffffff; ,ffffffffffffffffffffff,               :ffffffffffj,,,,,,,,,,,
+,,,,,,,,,,,,tffffffffffffffffffffff      ;ffffffffffffffff;                 .fffffffffft,,,,,,,,,,,,
+,,,,,,,,,,,,,fffffffffffffffffffff           ,tfffffft;                    tfffffffffff,,,,,,,,,,,,,
+,,,,,,,,,,,,,;fffffffffffffffffff                                         tfffffffffff;,,,,,,,,,,,,,
+,,,,,,,,,,,,,,ffffffffffffffffff;                                        .ffffffffffff,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,ffffffffffffffff                                         :ffffffffffff,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,;jfffffffffffff                                         ffffffffffffj;,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,fffffffffffffi                                      ifffffffffffff,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,ifffffffffffff,                                    ,fffffffffffffi,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,tffffffffffffffi                                ifffffffffffffft,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,ifffffffffffffffi:                          :ifffffffffffffffi,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,jfffffffffffffffft.                    .tffffffffffffffffj,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,;fffffffffffffffffft:                :tffffffffffffffffff;,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,ffffffffffffffffffffffjt;;,,;;tjffffffffffffffffffffff,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,;ffffffffffffffffffffffffffffffffffffffffffffffffff;,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,tfffffffffffffffffffffffffffffffffffffffffffffft,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,jffffffffffffffffffffffffffffffffffffffffffffj,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,iffffffffffffffffffffffffffffffffffffffffi,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,ijffffffffffffffffffffffffffffffffffji,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, iffffffffffffffffffffffffffffffi ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;iffffffffffffffffffffffffffi;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;ijffffffffffffffffji;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,;;iiii;;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

data/README.markdown

@@ -359,6 +359,183 @@ long time. Like, long enough to cause a state transition domino effect. Let's mo
 Notice that this domino effect happened lazily when you call the `do!` method, or the `context.state.value` methods. Quite nice for systems where
 you persist your state to a db. 
 
+
+## Persistence
+
+How do you persist your state to a database? YASM will automatically persist/load your states to/from the database; it supports (or plans to support) the following ORMs:
+
+* couchrest_model (as of version 0.0.4)
+* mongoid (coming soon)
+* active_record (coming soon)
+
+For example, let's suppose our vending machine context was actually a CouchDB document, modelled with CouchRest::Model:
+
+    class VendingMachine < CouchRest::Model::Base
+      include Yasm::Context
+
+      start :waiting
+    end
+
+    #.....
+
+By simply mixing Yasm::Context into the document, our states will be automatically persisted to the database and loaded from the database.
+
+
+## Anonymous and Named States
+
+Up till now, we've been utilizing the anonymous state on our context. In other words, because we didn't wrap our `start :waiting` inside a `state` call, YASM
+assumed that we were simply going to be using the anonymous state on our class. Also, when we've called the `do!` method, we've called it directly on our context,
+which again assumes that you're attempting to apply an action to the anonymous state on your context. 
+
+What's an example of a named state? Perhaps we'd like to manage the electricity on our vending machine with a state machine. To do so, we'd simply: 
+
+    class VendingMachine
+      include Yasm::Context
+
+      start :waiting
+
+      state(:electricity) do
+        start :on
+      end
+    end
+
+    class Waiting;  include Yasm::State; end
+    class Vending;  include Yasm::State; end
+    class On;       include Yasm::State; end
+    class Off;      include Yasm::State; end
+
+    class Unplug
+      include Yasm::Action
+
+      triggers :off
+    end
+
+    class Plugin
+      include Yasm::Action
+
+      triggers :on
+    end
+
+    class Select
+      include Yasm::Action
+
+      triggers :vending
+    end
+
+Now our VendingMachine has two managed states: the anonymous state (that start in the `Waiting` state), and the "electricity" state (that starts in the `On` state).
+
+We can apply actions to each of these states independently: 
+
+    v = VendingMachine.new
+    
+    puts v.state.value 
+      #==> Waiting
+    
+    puts v.electricity.value
+      #==> On
+   
+    v.do! Select
+    
+    puts v.state.value 
+      #==> Vending
+ 
+    v.electricity.do! Unplug
+
+    puts v.electricity.value
+      #==> Off
+    
+## Action Callbacks
+
+How do you run a method before or after an action is applied to a yasm state within your context? Yasm::Context gives you the following two callback macros for this purpose: 
+`before_action` and `after_action`. They each accept two parameters: a symbol representing the method on the context you'd like called, and an options hash, where you 
+can specify `:only` or `:except` constraints. 
+
+For example: 
+
+    class Human
+      include Yasm::Context
+
+      start :alive
+      before_action :weigh_options, :except => :jump_off_building
+      after_action :consider_results, :only => :jump_off_building
+
+      private
+      def weigh_options
+        puts "You could, alternatively, jump off a building."
+      end
+
+      def consider_results
+        puts "Splendid!"
+      end
+    end
+
+    class Alive; include Yasm::State; end
+    class Dead;  include Yasm::State; end
+    
+    class GoToWork
+      include Yasm::Action
+    end
+    
+    class JumpOffBuilding
+      include Yasm::Action
+      triggers :dead
+
+      def execute
+        puts "Weeeeeee!"
+      end
+    end
+
+Now, when we apply actions to the anonymous state, before and after actions will run when appropriate:
+
+    you = Human.new
+
+    you.do! GoToWork
+      #==> "You could, alternatively, jump off a building."
+
+    you.do! JumpOffBuilding
+      #==> "Weeeeeee!"
+      #==> "Splendid!"
+
+Just as you can use `before_action` and `after_action` with the anonymous state, you can use it with named states as well:
+
+    class VendingMachine
+      include Yasm::Context
+
+      state(:electricity) do
+        start :on
+        before_action :warn, :only => :unplug
+        after_action  :sigh
+      end
+
+      private
+      def warn
+        puts "Wait! Don't unplug me!!!"
+      end
+
+      def sigh
+        puts "sigh...."
+      end
+    end
+
+    class On; include Yasm::State; end
+    class Off; include Yasm::State; end
+
+    class Unplug
+      include Yasm::Action
+      triggers :off
+
+      def execute
+        puts "unplugging...."
+      end
+    end
+
+    v = VendingMachine.new
+
+    v.electricity.do! Unplug
+      #==> "Wait! Don't unplug me!!!"
+      #==> "unplugging...."
+      #==> "sigh...."
+
 ## PUBLIC DOMAIN
 
 This software is committed to the public domain. No license. No copyright. DO ANYTHING! 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.6

data/features/action_callbacks.feature

@@ -0,0 +1,22 @@
+Feature: Action Callbacks
+  As a programmer
+  I want to have before and after hooks into actions
+  So that I can customize my state machine
+
+  Scenario: After Action callback
+    Given a context that I intend to attach action callbacks to
+    When I create an after action callback with no constraints
+    Then that callback should be called after all actions
+    When I create an after action callback with an `only` constraint
+    Then that callback should be called only when the particular action(s) run
+    When I create an after action callback with an `except` constraint
+    Then that callback should not be called when the particular action(s) run 
+
+  Scenario: Before Action callback
+    Given a context that I intend to attach before action callbacks to
+    When I create a before action callback with no constraints
+    Then that callback should be called before all actions
+    When I create a before action callback with an `only` constraint
+    Then that before callback should be called only when the particular action(s) run
+    When I create a before action callback with an `except` constraint
+    Then that before callback should not be called when the particular action(s) run 

data/features/actions.feature

@@ -0,0 +1,9 @@
+Feature: Actions
+  As a programmer
+  I want to be able to apply actions to a state
+  So that I can cause the state to transition
+
+  Scenario: Applying actions to a state
+  Given a context
+  When I apply an action to it that triggers a state transition
+  Then the state should transition appropriately

data/features/final_states.feature

@@ -0,0 +1,14 @@
+Feature: 
+  As a programmer
+  I want to declare a state as FINAL
+  So that I can forbid any futher actions or state transitions
+
+  Scenario: Declaring a state FINAL
+    Given a state that I intend to declare final
+    When I declare it final
+    Then it should return true when asked if it's a FINAL state
+
+  Scenario: Applying an action to a FINAL state
+    Given a final state
+    When I attempt to apply an action to it
+    Then I should get an exception

data/features/persistance/couchrest_model_persistance.feature

@@ -0,0 +1,22 @@
+@couch
+Feature: CouchRest::Model Persistance
+  As a CouchDB hacker
+  I want the states on my CouchRest::Mode::Base context persisted to CouchDB
+  So that I can incorporate YASM into my relaxing database environment
+
+  Scenario: Yasm::Persistence::CouchRest::Model should be auto included when Yasm::Context is included inside a CouchRest::Model::Base derived class
+    Given a class that inherits from CouchRest::Model::Base
+    When I mix Yasm::Context into it
+    Then Yasm::Persistence::CouchRest::Model should be autoincluded as well
+
+  Scenario: Saving state to CouchRest::Model::Base derived classes
+    Given a couchrest model context
+    When I save that context to CouchDB
+    Then the states should be saved in the document
+
+  Scenario: Loading state from CouchRest::Model::Base derived classes
+    Given a couchrest model context with state saved in the database
+    When I load that context
+    Then the states should be restored
+    And the states should be fast forwarded
+

data/features/state_with_limited_actions.feature

@@ -0,0 +1,13 @@
+Feature: State's that limit actions
+  As a programmer
+  I want to limit the actions that can be applied to a state
+  So that I can control the workflow of my state machine
+
+  Scenario: Declaring valid actions
+    Given a state
+    When I declare that only certain actions can be applied to it
+    Then those actions should be stored on the state class
+
+  Scenario: Determing if an action is valid for a given state
+    Given a state with limited actions
+    Then I should be able to determine whether a given action is valid for a given state

data/features/states_with_time_limits.feature

@@ -0,0 +1,29 @@
+Feature: Time limits on states
+  As a programmer
+  I want to be able to put minimum and maximum time limits on states
+  So that I can simulate better the real world
+
+  Scenario: Declaring a minimum time limit
+    Given a state that I intend to declare a minimum time limit on
+    When I declare a minimum time limit on it
+    Then it should store that time limit on the state class
+
+  Scenario: Applying an action to a state with a minimum time limit
+    Given a state that has a minimum time limit
+    When I apply an action to that state before its minimum time limit has been reached
+    Then I should get a minimum time limit exception
+    When I apply an action to that state after its minimum time limit has been reached
+    Then I should not get a minimum time limit exception
+
+  Scenario: Declaring a maximum time limit
+    Given a state that I intend to declare a maximum time limit on
+    When I declare a maximum time limit on it without an action
+    Then it should raise an argument error exception
+    When I declare a maximum time limit on it with an action
+    Then it should store that maximum time limit and action on the state class
+
+  Scenario: State transition dominoe with max time limits
+    Given a context with the potential for a max time limit dominoe effect
+    When I wait long enough to cause the dominoe effect
+    Then the dominoe effect should occur when I ask for the state
+    And the dominoe effect should occur when I attempt to apply an action to the context

data/features/step_definitions/action_callback_steps.rb

@@ -0,0 +1,190 @@
+Given /^a context that I intend to attach action callbacks to$/ do
+  class ActionCallbackContext
+    include Yasm::Context
+    start :action_callback_state
+  end
+
+  class ActionCallbackState
+    include Yasm::State
+  end
+
+  class Action1; include Yasm::Action; end
+  class Action2; include Yasm::Action; end
+  class Action3; include Yasm::Action; end
+  class Action4; include Yasm::Action; end
+end
+
+When /^I create an after action callback with no constraints$/ do
+  class ActionCallbackContext
+    attr_accessor :counter
+    after_action :increment_counter
+
+    def initialize
+      @counter = 0
+    end
+
+    private
+    def increment_counter
+      @counter += 1
+    end
+  end
+end
+
+Then /^that callback should be called after all actions$/ do
+  context = ActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action1
+  context.counter.should == 1
+  context.do! Action2
+  context.counter.should == 2
+  context.do! Action3
+  context.counter.should == 3
+  context.do! Action4
+  context.counter.should == 4
+end
+
+When /^I create an after action callback with an `only` constraint$/ do
+  class ActionCallbackContext
+    after_action :decrement_counter, :only => [:action1, :action2]
+
+    private
+    def decrement_counter
+      @counter -= 1
+    end
+  end
+end
+
+Then /^that callback should be called only when the particular action\(s\) run$/ do
+  context = ActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action1
+  context.counter.should == 0
+  context.do! Action2
+  context.counter.should == 0
+  context.do! Action3
+  context.counter.should == 1
+  context.do! Action4
+  context.counter.should == 2 
+end
+
+When /^I create an after action callback with an `except` constraint$/ do
+  class ActionCallbackContext
+    after_action :double_counter, :except => :action3
+
+    private
+    def double_counter
+      @counter *= 2
+    end
+  end
+end
+
+Then /^that callback should not be called when the particular action\(s\) run$/ do
+  context = ActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action3
+  context.counter.should == 1
+  context.do! Action3
+  context.counter.should == 2
+  context.do! Action4
+  context.counter.should == 6
+  context.do! Action4
+  context.counter.should == 14
+  context.do! Action1
+  context.counter.should == 28
+end
+
+
+Given /^a context that I intend to attach before action callbacks to$/ do
+  class BeforeActionCallbackContext
+    include Yasm::Context
+    start :action_callback_state
+  end
+end
+
+When /^I create a before action callback with no constraints$/ do
+  class BeforeActionCallbackContext
+    attr_accessor :counter
+    before_action :increment_counter
+
+    def initialize
+      @counter = 0
+    end
+
+    private
+    def increment_counter
+      @counter += 1
+    end
+  end
+
+  class ActionCallbackState
+    include Yasm::State
+  end
+
+  class Action1; include Yasm::Action; end
+  class Action2; include Yasm::Action; end
+  class Action3; include Yasm::Action; end
+  class Action4; include Yasm::Action; end
+end
+
+Then /^that callback should be called before all actions$/ do
+  context = BeforeActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action1
+  context.counter.should == 1
+  context.do! Action2
+  context.counter.should == 2
+  context.do! Action3
+  context.counter.should == 3
+  context.do! Action4
+  context.counter.should == 4
+end
+
+When /^I create a before action callback with an `only` constraint$/ do
+  class BeforeActionCallbackContext
+    before_action :decrement_counter, :only => [:action1, :action2]
+
+    private
+    def decrement_counter
+      @counter -= 1
+    end
+  end
+end
+
+Then /^that before callback should be called only when the particular action\(s\) run$/ do
+  context = BeforeActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action1
+  context.counter.should == 0
+  context.do! Action2
+  context.counter.should == 0
+  context.do! Action3
+  context.counter.should == 1
+  context.do! Action4
+  context.counter.should == 2 
+end
+
+When /^I create a before action callback with an `except` constraint$/ do
+  class BeforeActionCallbackContext
+    before_action :double_counter, :except => :action3
+
+    private
+    def double_counter
+      @counter *= 2
+    end
+  end
+end
+
+Then /^that before callback should not be called when the particular action\(s\) run$/ do
+  context = BeforeActionCallbackContext.new
+  context.counter.should == 0
+  context.do! Action3
+  context.counter.should == 1
+  context.do! Action3
+  context.counter.should == 2
+  context.do! Action4
+  context.counter.should == 6
+  context.do! Action4
+  context.counter.should == 14
+  context.do! Action1
+  context.counter.should == 28
+end