barebone-fsm 0.0.2.1 → 0.0.3

data/MIT-LICENSE

@@ -1,22 +1,18 @@
 Copyright (c) 2013, Md. Imrul Hassan
 
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -3,17 +3,19 @@ This module, barebone-fsm, implements a basic finite-state machine (FSM).
 An FSM consists of a finite number of states,
 with one of them being the current state of the FSM.
 Transitions are defined between states, which are triggered on events.
-For details on FSM, see this wiki page: {http://en.wikipedia.org/wiki/Finite-state_machine FSM}.
+For details on FSM, see this wiki page: {FSM}[http://en.wikipedia.org/wiki/Finite-state_machine].
 
-The motivation behind the module was to implement a very basic barebone FSM in Ruby.
+The motivation behind the module was to implement a very basic barebone {FSM} in Ruby.
 Features are kept at minimum as well as the code.
 Only two classes for the FSM are defined as the following:
-* FSM -> the finite state machine class
-* FSMState -> the state class
+* {FSM::FSM} -> the finite state machine class
+* {FSM::FSMState} -> the state class
+The {FSM} Module when included in a class also provides few convenience methods.
+For further details see the README file.
 
 Author:: Md. Imrul Hassan (mailto:mihassan@gmail.com)
 Copyright:: Copyright (c) 2013, Md. Imrul Hassan
-License:: Barebone-fsm is released under the MIT license. Please check the {file:MIT-LICENSE LICENSE} file for more details.
+License:: Barebone-fsm is released under the MIT license
 
 == Features
 Apart from having support for states and events, this module offers the following features:
@@ -21,7 +23,9 @@ Apart from having support for states and events, this module offers the followin
 2. Default event for each state
 3. Entry and exit events for each state
 4. DSL like coding style
-5. Access to state variables (including @state and @event) inside event blocks.
+5. Access to state variables (including @state and @event) inside event blocks
+6. The module when included in a Class, provides methods to setup the state machine and trigger events
+7. Dynamic methods generated for the Class to check states, events and trigger events.
 
 == Usage
 The FSM can be setup and triggered Succinctly using Domain Specific Language(DSL) like coding style.
@@ -29,13 +33,13 @@ There are two methods to build and run which are defined for both FSM and FSMSta
 These methods, #build and #run, are alias of each other and can be used interchangebly.
 A basic fintite-state machine for a microwave is simulated in the following example:
 
-  fsm = FSM::FSM.new(:stopped) # :stopped is the default state to fall back
+  fsm = FSM::FSM.new(:stopped)
   
-  fsm.build do # the states and events can be configured within the build block
-    state :stopped do # the events can be setup within the state block for :stopped state
-      event :open do # the event block is run when the event :open is triggered
+  fsm.build do
+    state :stopped do
+      event :open do
         puts "[Stopped]: Door Opened"
-        :open # the return value of the event block, :open, is the next state
+        :open
       end
       event :start do
         puts "[Stopped]: Started"
@@ -44,40 +48,43 @@ A basic fintite-state machine for a microwave is simulated in the following exam
     end
     state :open do
       event :close do
-        puts "[#{@state}]: Door #{@event}" # the event block has access to state variables such as @state and @event
+        puts "[#{@state}]: Door #{@event}"
         :stopped
       end
     end
     state :started do
       event :open do
-        @open_time = Time::now # new state variables can be defined
+        @open_time = Time::now
         puts "[Started]: Door Opened"
         :open
       end
       event :stop do
-        puts "The door was opened at #{@open_time}" # state variables from other event blocks can be used
+        puts "The door was opened at #{@open_time}"
         puts "[Started]: Door Stopped after #{elapsed_time}"
         :stopped
       end
     end
   end
   
-  fsm.run do # the events can be triggered from the run block
+  fsm.run do
     event :start
     event :open
     event :close
     event :start
     event :stop
   end
-  
-  puts fsm
 
 == Status
-The module works as it is, but further testing and documentation is needed.
+The module works as it is, I have added some testing and documentation; it may be expanded.
 The api is not stable yet, it may go trhough lots of changes before the first stable version is released.
 I am open to any suggestion or request to support custom features.
 
 == Changes
+* Version: 0.0.3
+  * Added Module level methods for easy access to states and events.
+  * Added documentations for all the methods.
+  * Added Module level dynamic methods to check states, events and to trigger events.
+  * Added some testing codes using RSpec.
 * Version: 0.0.2
   * State variables defined in other states can be accessed in the event block as well.
 * Version: 0.0.1.3

data/example/door.rb

@@ -1,9 +1,8 @@
-require '../lib/barebone-fsm'
+require_relative 'example_helper'
 
 fsm = FSM::FSM.new(:default)
-
 fsm.build do
-
+  @x = 0
   state :default do
     event :open do
       puts "#{@x} transition: default->open"
@@ -17,7 +16,6 @@ fsm.build do
 
   state :open do
     event :close do
-      @x ||= 0
       @x+=1
       puts "#{@x} transition: open->close"
       :close
@@ -26,14 +24,13 @@ fsm.build do
 
   state :close do
     event :open do
-      @x ||= 0
       @x+=1
       puts "#{@x} transition: close->open"
       :open
     end
   end
 
-end
+  end
 
 puts fsm
 

data/example/example_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/barebone-fsm'

data/example/microwave.rb

@@ -1,4 +1,4 @@
-require '../lib/barebone-fsm'
+require_relative 'example_helper'
 
 fsm = FSM::FSM.new
 
@@ -44,6 +44,7 @@ fsm.run do
   event :close
   event :start
   event :stop
+  
 end
 
 puts fsm

data/example/vehicle_class.rb

@@ -0,0 +1,38 @@
+require_relative 'example_helper'
+
+class Vehicle
+  
+  include FSM
+  
+  def initialize
+    build do
+      state :parked do event :start => :running, :open => :open end
+      state :running do event :park => :parked end
+      state :open do event :park => :parked end
+    end
+  end
+  
+  def show_fsm
+    puts @fsm
+  end
+end
+
+veh = Vehicle.new
+
+puts "It is parked" if veh.is_parked?
+
+puts "It can start" if veh.can_start?
+
+veh.start
+
+puts veh.state
+
+veh.state :turned_off
+veh.state :parked do event :turn_off => :turned_off end
+veh.event :turn_off
+
+puts "It is parked" if veh.is_parked?
+
+puts "It can start" if veh.can_start?
+
+#veh.start

data/lib/barebone-fsm.rb

@@ -5,42 +5,59 @@
 # Transitions are defined between states, which are triggered on events.
 # For details on FSM, see this wiki page: {FSM}[http://en.wikipedia.org/wiki/Finite-state_machine].
 #
-# The motivation behind the module was to implement a very basic barebone FSM in Ruby.
+# The motivation behind the module was to implement a very basic barebone {FSM} in Ruby.
 # Features are kept at minimum as well as the code.
 # Only two classes for the FSM are defined as the following:
-# * FSM -> the finite state machine class
-# * FSMState -> the state class
-# 
+# * {FSM::FSM} -> the finite state machine class
+# * {FSM::FSMState} -> the state class
+# The {FSM} Module when included in a class also provides few convenience methods.
 # For further details see the README file.
 #
 # Author:: Md. Imrul Hassan (mailto:mihassan@gmail.com)
-# Copyright:: Copyright: Md. Imrul Hassan, 2013
+# Copyright:: Copyright (c) 2013, Md. Imrul Hassan
+# License:: Barebone-fsm is released under the MIT license
 #
 module FSM
-
+  
+  ##
   # FSMState class represents a state of the finite state machine.
   # 
-  # == Usage
-  #   state = FSMState.new :state_name
-  #   state.event(:event_name) do # creates the event when block is given
+  # @example Setup the event code for a state through block
+  #   state = FSM::FSMState.new :state_name
+  #   state.event(:event_name) do
   #     puts "#{@event} triggered on state #{@state}"
-  #     :new_state
+  #     :next_state
   #   end  
-  #   puts state
-  #   state.event :event_name # triggers the event when block is absent
+  #
+  # @example Setup multiple events specifying only the next state for each event using Hash map
+  #   state = FSM::FSMState.new :initial_state
+  #   state.event :go_left => :left_state, :go_right => :right_state
+  #
+  # @example Trigger an event for the previous example
+  #   state.event :go_left
   #
   class FSMState
 
-    # The readonly state variable represents an unique state.
-    # Though it can have any data type, usage of symbol or string is preferable.
+    ##
+    # The name of the state.
     attr_reader :state
+    ##
+    # The events for this state mapped to corresponding event codes.
+    attr_reader :events
 
+    ##
+    # @param state_machine [FSM::FSM] the FSM object representing the state machine containing this state
+    # @param state_name [Symbol] the unique name for this state
+    #
     def initialize(state_machine, state_name) 
       @fsm = state_machine
       @state = state_name
       @events = {}
     end
-
+    
+    ##
+    # A String representation of the FSMState object.
+    #
     def to_s() 
       @state.to_s + 
         ": [" + 
@@ -48,12 +65,44 @@ module FSM
         "]" 
     end
 
-    # When the event_block is provided, it sets up a new event for this state.
-    # Otherwise, when the event_block is missing, the event_name is triggered.
+    ##
+    # Setup or trigger an event.
+    # It sets up a new event when the event_block is provided or event_name is a Hash map.
+    # The event_name is triggered otherwise. 
     # If the event is nil or not already setup, then the default event is triggered.
+    #
+    # @overload event(event_name, &event_block)
+    #   Sets up an event for this state with the given event_block parameter.
+    #   @param event_name [Symbol] the name of the event to set up
+    #   @param event_block [block] the block of code to run when this event will be triggered
+    #
+    # @overload event(events_hash)
+    #   Sets up multiple events where each element of the Hash map corresponds to one event.
+    #   @param events_hash [Hash<Symbol,Symbol>] the Hash object mapping events to the corresponding next states
+    #
+    # @overload event(event_name)
+    #   Triggers the event named event_name for this state.
+    #   @param event_name [Symbol] the name of the event to trigger
+    #
+    # @example Setup an event by block
+    #   state.event(:event_name) do
+    #     puts "#{@event} triggered on state #{@state}"
+    #     :next_state
+    #   end  
+    #
+    # @example Setup an event by Hash
+    #   state.event :go_left => :left_state, :go_right => :right_state
+    #
+    # @example Trigger an event
+    #   state.event :go_left
+    #
     def event(event_name, &event_block)
-      if event_name and block_given? then
+      if block_given? then
         @events[event_name] = event_block
+      elsif event_name.is_a?(Hash) then
+        event_name.each{ |ev, st|
+          @events[ev] = Proc.new{st}
+        }
       elsif event_name and @events.has_key? event_name then
         @fsm.event = event_name
         @fsm.instance_eval &@events[event_name]
@@ -63,9 +112,27 @@ module FSM
       end
     end
 
-    # The #build/#run method sets up the events as given in the build_block.
+    ##
+    # The #build/#run method sets up the events described as DSL code in the build_block.
     # Only event method is supported within the build_block with the name of the event and an optional block supplied.
-    # The operation for each such line is carried out by the #event method.
+    # The operation for each such line is carried out by the {FSM::FSMState#event} method.
+    # @see FSM::FSMState#event
+    #
+    # @param build_block [block] the block of code with sevaral event methods
+    #
+    # @example Using block to setup events
+    #   state.build do
+    #     event :event_name do
+    #       puts "#{@event} triggered on state #{@state}"
+    #       :next_state
+    #     end
+    #   end
+    #
+    # @example Using block to trigger events
+    #   state.build do
+    #     event :event_name
+    #   end
+    #
     def build(&build_block)
       self.instance_eval &build_block
     end
@@ -74,27 +141,51 @@ module FSM
     
   end
 
+  ##
   # This class implements the finite-state machine.
   # FSM class exposes the states it contains and can trigger an event.
-  # States are created on the fly first time it's referenced through index operator [].
+  # States are created on the fly first time it's referenced through index operator [] or #state method.
   # 
   # The FSM state transits to the default state if the latest event does not define the next state.
   # If default state is not set, then state does not change on undefined state.
   # The initial state of the FSM is the first state mentioned.
   # This can be either the default state if defined or the first referenced state.
   #
-  # == Usage
-  #   fsm = FSM.new :default_state
-  #   fsm[:default_state].event(:first_event) do # the state is defined and referenced at the same time
+  # @example Setting up finite state machine and triggering events without blocks
+  #   fsm = FSM::FSM.new(:default_state)
+  #   fsm[:default_state].event(:first_event) do
   #     puts "The first transition from the default_state to state_name"
-  #     :state_name # the next state is defined here
+  #     :state_name
+  #   end
+  #   fsm.event :first_event
+  #
+  # @example Setting up finite state machine and triggering events with blocks
+  #   fsm = FSM::FSM.new
+  #   fsm.build do
+  #     state :initial_state do
+  #       event :an_event => :next_state
+  #     end
+  #   end
+  #   fsm.run do
+  #     event :an_event
   #   end
   #
   class FSM
     
-    attr_writer :event
+    ##
+    # The list of all the states.
+    attr_reader :states
     
-    # Creates a new FSM object with an optional default state set.
+    ##
+    # Creates a new FSM object with an optional default state.
+    # @param default_state [Symbol] the name for the default state
+    #
+    # @example Create a new finite state machine without default state
+    #   fsm = FSM::FSM.new
+    #
+    # @example Create a new finite state machine with default state
+    #   fsm = FSM::FSM.new(:default_state)
+    #
     def initialize(default_state=nil) 
       @states = {}
       if default_state then
@@ -102,7 +193,10 @@ module FSM
         @states[@default] = FSMState.new(self, @default)
       end
     end
-    
+
+    ##
+    # A String representation of the FSM object.    
+    #
     def to_s() 
       "FSM" + 
         ": {" + 
@@ -112,8 +206,24 @@ module FSM
         "}" 
     end
     
-    # It returns the FSMState object for state_name.
-    # If the state is missing, then it first sets up the state, and then returns the newly created state.
+    ##
+    # Creates and/or returns an FSMState object.
+    # If an FSMState object with state_name is present, then returns that object.
+    # Otherwise, it creates a new FSMState object first and then returns that object.
+    # If state_name is not given, then current state object is returned.
+    #
+    # @overload []()
+    #   The current FSMState object is returned.
+    #
+    # @overload [](state_name)
+    # Returns the FSMState object with state_name.
+    # If it is not setup yet, a new FSMState object is created first and then returned.
+    #
+    # @example
+    #   fsm = FSM::FSM.new
+    #   new_state = fsm[:new_state]
+    #   print fsm[:new_state].state
+    # 
     def [](state_name=nil) 
       state_name ||= @state
       if state_name and not @states.has_key? state_name then
@@ -123,9 +233,39 @@ module FSM
       @states[state_name]
     end
 
-    # When the state_block is provided, it sets up a new state.
-    # Otherwise, when the state_block is missing, the FSMState object for state_name is returned.
-    # If called without any parameter, then the current state is returned.
+    ##
+    # Sets up and/or returns an FSMState object.
+    # It sets up a new state with all its events when the state_block is provided.
+    # If state_block is missing, then it creates and/or returns an FSMState object with state_name.
+    # If state_name is not given, then current state object is returned.
+    #
+    # @overload state(state_name, state_block)
+    #   Sets up a state with the given state_block parameter.
+    #   @param state_name [Symbol] the name of the state to set up
+    #   @param state_block [block] the block of code to setuo the state
+    #
+    # @overload state(state_name)
+    #   Create and/or return a state object.
+    #   @param state_name [Symbol] the name of the state
+    #
+    # @overload state()
+    #   Return current state object.
+    #
+    # @example Setup a state by block
+    #   fsm = FSM::FSM.new
+    #   new_state = fsm.state(:new_state) do 
+    #     event :an_event => :next_state
+    #   end
+    #
+    # @example Create a new state
+    #   fsm = FSM::FSM.new
+    #   new_state = fsm.state(:new_state)
+    #
+    # @example Return the current state
+    #   fsm = FSM::FSM.new
+    #   new_state = fsm.state(:new_state)
+    #   print fsm.state.state
+    #
     def state(state_name=nil, &state_block)
       if block_given? then
         self.[](state_name).build &state_block
@@ -134,23 +274,55 @@ module FSM
       end
     end
     
-    # It triggers the event_name event and changes the state of the FSM to its new state.
+    ##
+    # Trigger a series of events.
     # The :entry and :exit events are called on the leaving state and the entering state.
     # If the event does not mention the new state, then the state changes to the default state.
-    def event(event_name)
-      @event = event_name 
-      @states[@state].event :exit
-      new_state = @states[@state].event event_name
-      new_state = nil if not @states.has_key? new_state
-      new_state ||= @default
-      new_state ||= @state 
-      @state = new_state
-      @states[@state].event :enter
+    #
+    # @param event_names [Array<Symbol>] the list of event names
+    #
+    # @example Triggers two events
+    #   state.event(:first_event, :second_event)
+    #
+    def event(*event_names)
+      for event_name in event_names do
+        @event = event_name 
+        @states[@state].event :exit
+        new_state = @states[@state].event event_name
+        new_state = nil if not @states.has_key? new_state
+        new_state ||= @default
+        new_state ||= @state 
+        @state = new_state
+        @states[@state].event :enter
+      end
     end
     
-    # The #build/#run method sets up the states and events as given in the build_block.
-    # Only state and event methods are supported within the build_block with the name of the state/event and a block supplied.
+    # @private
+    def event=(event_name)
+      @event = event_name
+    end
+    
+    ##
+    # The #build/#run method sets up the states and events as DSL code in the build_block.
+    # Only state and event methods are supported within the build_block with the name of the state/event and an optional block supplied.
     # The operation for each such line is carried out by the #state/#event method.
+    # @see FSM::FSM#state
+    # @see FSM::FSM#event
+    #
+    # @example Using block to setup states and trigger events
+    #   fsm = FSM::FSM.new
+    #   fsm.build do
+    #     state :stopped do
+    #       event :run => :running
+    #     end
+    #     state :running do
+    #       event :stop => :stopped
+    #     end
+    #   end
+    #   fsm.run do
+    #     event :run, :stop
+    #   end
+    #
     def build(&build_block)
       self.instance_eval &build_block
     end
@@ -159,4 +331,158 @@ module FSM
 
   end
 
+  ##
+  # The #build/#run method sets up the states and events as DSL code.
+  # Only state and event methods are supported within the build_block with the name of the state/event and an optional block supplied.
+  # The operation for each such line is carried out by the {FSM::FSM#state}/{FSM::FSM#event} method.
+  # @see FSM::FSM#state
+  # @see FSM::FSM#event
+  #
+  # @example Using block to setup states and trigger events
+  #   fsm = FSM::FSM.new
+  #   fsm.build do
+  #     state :stopped do
+  #       event :run => :running
+  #     end
+  #     state :running do
+  #       event :stop => :stopped
+  #     end
+  #   end
+  #   fsm.run do
+  #     event :run, :stop
+  #   end
+  #
+  def build(&build_block)
+    @fsm ||= FSM.new
+    @fsm.build(&build_block)
+  end
+  alias_method :run, :build
+  
+  ##
+  # Trigger a series of events.
+  # The :entry and :exit events are called on the leaving state and the entering state.
+  # If the event does not mention the new state, then the state changes to the default state.
+  # @param event_names [Array<Symbol>] the list of event names
+  # @see FSM::FSM#event
+  #
+  def event(*event_names)
+    @fsm.event(*event_names)
+  end
+
+  ##
+  # Sets up and/or returns an FSMState object.
+  # It sets up a new state with all its events when the state_block is provided.
+  # If state_block is missing, then it creates and/or returns an FSMState object with state_name.
+  # If state_name is not given, then current state object is returned.
+  # @see FSM::FSM#state
+  #
+  # @overload state(state_name, state_block)
+  #   Sets up a state with the given state_block parameter.
+  #   @param state_name [Symbol] the name of the state to set up
+  #   @param state_block [block] the block of code to setuo the state
+  #
+  # @overload state(state_name)
+  #   Create and/or return a state object.
+  #   @param state_name [Symbol] the name of the state
+  #
+  # @overload state()
+  #   Return current state object.
+  #  
+  def state(state_name=nil, &state_block)
+    @fsm.state(state_name, &state_block)
+  end
+  
+  # The list of names of all the states
+  def states
+    @fsm.states.keys
+  end
+
+  ##
+  # @!method is_state?
+  #   Checks if the current state is state.
+  #
+  #   @example Vehicle running
+  #     class Vehicle
+  #       include FSM
+  #       def initialize
+  #         build do
+  #           state :parked do event :start => :running end
+  #           state :running do event :park => :parked end
+  #         end
+  #       end
+  #     end
+  #     veh = Vehicle.new
+  #     puts "Vehicle running." if veh.is_running?
+  #     veh.start
+  #     puts "Vehicle running." if veh.is_running?
+  
+  ##
+  # @!method can_trigger?
+  #   Checks if trigger is an event on the current state.
+  #
+  #   @example Vehicle start if it can
+  #     class Vehicle
+  #       include FSM
+  #       def initialize
+  #         build do
+  #           state :parked do event :start => :running end
+  #           state :running do event :park => :parked end
+  #         end
+  #       end
+  #     end
+  #     veh = Vehicle.new
+  #     veh.start if veh.can_start?
+
+  ##
+  # @!method trigger
+  #   Triggers the evnt for current state.
+  #   It should be used with #can_trigger? method, as if the method is only defined id it can be triggered.
+  #
+  # @example Vehicle start if it can
+  #   class Vehicle
+  #     include FSM
+  #     def initialize
+  #       build do
+  #         state :parked do event :start => :running end
+  #         state :running do event :park => :parked end
+  #       end
+  #     end
+  #   end
+  #   veh = Vehicle.new
+  #   # veh.park will generate NoMethodError as vehicle can not park from parked state
+  #   veh.park if veh.can_park?
+  #   veh.start if veh.can_start?
+
+  def respont_to?(sym)
+    if @fsm then
+      match_can_method?(sym) || match_is_method?(sym) || match_run_method?(sym) || super
+    end
+  end
+  
+  def method_missing(sym, *args, &block)
+    if match = match_can_method?(sym) then
+      @fsm.state.events.include?(match)
+    elsif match = match_is_method?(sym) then
+      @fsm.state.state == match
+    elsif match = match_run_method?(sym) 
+      @fsm.event(match)
+    else 
+      super
+    end
+  end
+
+  private
+
+  def match_can_method?(sym)
+    sym.to_s =~ /can_(.*)\?/; $1 && $1.to_sym
+  end
+
+  def match_is_method?(sym)
+    sym.to_s =~ /is_(.*)\?/; $1 && $1.to_sym
+  end
+ 
+  def match_run_method?(sym)
+    @fsm.state.events.include?(sym)
+  end
+
 end

data/spec/fsm_spec.rb

@@ -0,0 +1,113 @@
+require_relative 'spec_helper'
+
+describe FSM::FSM do
+  subject{FSM::FSM.new()}
+
+  describe "#initialize" do
+    context "with default state" do
+      subject{FSM::FSM.new(:default)}
+      its(:states){should have(1).item}
+    end
+    context "without default state" do
+      its(:states){should be_empty}
+    end
+  end
+  
+  describe "#to_s" do
+    context "with default state" do
+      subject{FSM::FSM.new(:default)}
+      specify{subject.to_s.should be_eql("FSM: {default: []}")}
+    end
+    context "without default state" do
+      specify{subject.to_s.should be_eql("FSM: {}")}
+    end
+    context "with one state" do
+      before{subject.state(:first_state)}
+      specify{subject.to_s.should be_eql("FSM: {>first_state: []}")}
+    end
+    context "with two states" do
+      before{subject.state(:first_state)}
+      before{subject.state(:second_state)}
+      specify{subject.to_s.should be_eql("FSM: {>first_state: [], second_state: []}")}
+    end
+    context "with states and events" do
+      before{subject.state(:first_state){event :first_event => :second_state}}
+      before{subject.state(:second_state){event :second_event => :first_state}}
+      specify{subject.to_s.should be_eql("FSM: {>first_state: [first_event], second_state: [second_event]}")}
+    end
+  end
+  
+  describe "#state" do
+    context "with a state block" do
+      before{subject.state(:first_state){event :first_event => :second_state}}
+      before{subject.state(:second_state){event :second_event => :first_state}}
+      its(:states){should_not be_empty}
+      its(:states){should have(2).items}
+      describe "state" do
+        specify{subject.state.state.should be(:first_state)}
+      end
+    end
+    context "without a state block" do
+      before{subject.state(:first_state)}
+      its(:states){should_not be_empty}
+      its(:states){should have(1).items}
+      describe "state" do
+        specify{subject.state.state.should be(:first_state)}
+      end
+    end
+    context "without any states" do
+      its(:states){should be_empty}
+      its(:state){should be_nil}
+    end    
+    context "with some states" do
+      before{subject.state(:first_state)}
+      its(:states){should_not be_empty}
+      its(:states){should have(1).items}
+      its(:state){should_not be_nil}
+    end    
+  end
+
+  describe "#event" do
+    before{subject.state(:first_state){event :first_event => :second_state}}
+    before{subject.state(:second_state){event :second_event => :first_state}}
+      before{subject.event :first_event}
+    describe "state" do
+      specify{subject.state.state.should be(:second_state)}
+    end
+  end
+
+  describe "#build" do
+    before{subject.build{state :a_state do event :an_event do :new_state end end}}
+    its(:states){should_not be_empty}
+    its(:states){should have(1).items}
+    its(:state){should_not be_nil}
+    describe "state" do
+      specify{subject.state.state.should be(:a_state)}
+    end
+  end
+    
+  describe "#run" do
+    subject{FSM::FSM.new(:default)}
+    before{subject.state(:first_state){event :first_event => :second_state}}
+    before{subject.state(:second_state){event :second_event => :first_state}}
+
+    context "when triggered event exists" do
+      before{subject.run{event :first_event}}
+      describe "state" do
+        specify{subject.state.state.should be(:second_state)}
+      end
+    end
+    context "when triggered event does not exist" do
+      before{subject.run{event :unknown_event}}
+      describe "state" do
+        specify{subject.state.state.should be(:default)}
+      end
+    end
+    context "when neither triggered event nor default state exists" do
+      describe "state" do
+        specify{subject.state.state.should be(:first_state)}
+      end
+    end
+  end
+
+end

data/spec/fsmstate_spec.rb

@@ -0,0 +1,117 @@
+require_relative 'spec_helper'
+
+describe FSM::FSMState do
+  let(:fsm){FSM::FSM.new}
+  subject{FSM::FSMState.new(fsm, :state_name)}
+
+  describe "#initialize" do
+    context "with parameter :state_name" do
+      its(:state){should be(:state_name)}
+      its(:state){should_not be(:wrong_name)}
+      its(:events){should be_a_kind_of(Hash)}
+      its(:events){should be_empty}
+    end
+  end
+  
+  describe "#to_s" do
+    context "with no events" do
+      specify{subject.to_s.should be_eql("state_name: []")}
+    end
+    context "with one event" do
+      before{subject.event(:first_event => :new_state)}
+      specify{subject.to_s.should be_eql("state_name: [first_event]")}
+    end
+    context "with two events" do
+      before{subject.event(:first_event => :new_state, :second_event => :new_state)}
+      specify{subject.to_s.should be_eql("state_name: [first_event, second_event]")}
+    end
+  end
+  
+  describe "#event" do
+    context "with an event block" do
+      before{subject.event(:an_event){:new_state}}
+      its(:events){should_not be_empty}
+      its(:events){should include(:an_event)}
+      its(:events){should have(1).item}
+      context "when the event is triggered" do
+        describe "the new state" do
+          specify{subject.event(:an_event).should be(:new_state)}
+        end
+      end
+    end
+    context "with a Hash map" do
+      before{subject.event(:an_event=>:new_state)}
+      its(:events){should_not be_empty}
+      its(:events){should include(:an_event)}
+      its(:events){should have(1).item}
+      context "when the event is triggered" do
+        describe "the new state" do
+          specify{subject.event(:an_event).should be(:new_state)}
+        end
+      end
+    end
+    context "when triggered event exists" do
+      before{subject.event(:an_event){:new_state}}
+      describe "the new state" do
+        specify{subject.event(:an_event).should be(:new_state)}
+      end
+    end
+    context "when triggered event does not exist" do
+      before{subject.event(:default){:new_state}}
+      it "should trigger default event" do
+        subject.event(:an_event).should be(:new_state)
+      end
+    end
+    context "when neither triggered event nor default event exists" do
+      it "should return nil" do
+        subject.event(:an_event).should be_nil
+      end
+    end
+  end
+
+  describe "#build" do
+    context "with an event block" do
+      before{subject.build{event :an_event do :new_state end }}
+      its(:events){should_not be_empty}
+      its(:events){should include(:an_event)}
+      its(:events){should have(1).item}
+      context "when the event is triggered" do
+        describe "the new state" do
+          specify{subject.event(:an_event).should be(:new_state)}
+        end
+      end
+    end
+    context "with a Hash map" do
+      before{subject.build{event :an_event=>:new_state}}
+      its(:events){should_not be_empty}
+      its(:events){should include(:an_event)}
+      its(:events){should have(1).item}
+      context "when the event is triggered" do
+        describe "the new state" do
+          specify{subject.event(:an_event).should be(:new_state)}
+        end
+      end
+    end
+  end
+    
+  describe "#run" do
+    context "when triggered event exists" do
+      before{subject.event(:an_event){:new_state}}
+      describe "the new state" do
+        specify{subject.run{event :an_event}.should be(:new_state)}
+      end
+    end
+    context "when triggered event does not exist" do
+      before{subject.event(:default){:new_state}}
+      it "should trigger default event" do
+        subject.run{event :an_event}.should be(:new_state)
+      end
+    end
+    context "when neither triggered event nor default event exists" do
+      it "should return nil" do
+        subject.run{event :an_event}.should be_nil
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/barebone-fsm'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: barebone-fsm
 version: !ruby/object:Gem::Version
-  version: 0.0.2.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-20 00:00:00.000000000 Z
+date: 2013-05-18 00:00:00.000000000 Z
 dependencies: []
 description: A barebone implementation of the finite state machine keeping simplicity
   in mind.
@@ -20,8 +20,12 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - example/door.rb
+- example/example_helper.rb
 - example/microwave.rb
-- spec/barebone-fsm_spec.rb
+- example/vehicle_class.rb
+- spec/fsm_spec.rb
+- spec/fsmstate_spec.rb
+- spec/spec_helper.rb
 - lib/barebone-fsm.rb
 - README.rdoc
 - MIT-LICENSE

data/spec/barebone-fsm_spec.rb

@@ -1,58 +0,0 @@
-require '../lib/barebone-fsm'
-
-describe FSM::FSM do
-  
-  context "with default state" do
-    
-    before :each do
-      @fsm = FSM::FSM.new :default
-    end
-    
-    it "should set the default state" do
-      @fsm.build do
-        state :start do
-        end
-      end
-      @fsm[].state.should be_eql(:start)
-      @fsm.run do
-        event :undefined
-      end
-      @fsm[].state.should be_eql(:default)
-    end
-  
-  end
-  
-  context "without default state" do
-    
-    before :each do
-      @fsm = FSM::FSM.new
-    end
-    
-    it "should not set the default state" do
-      @fsm.build do
-        state :start do
-        end
-      end
-      @fsm[].state.should be_eql(:start)
-      @fsm.run do
-        event :undefined
-      end
-      @fsm[].state.should be_eql(:start)
-    end
-    
-  end
-  
-  it "should create states on the fly" do
-    @fsm = FSM::FSM.new
-    @fsm[:new_state].state.should eq(:new_state)
-    @fsm.state(:another_state).state.should eq(:another_state)
-  end
-  
-  it "should set current state to the first accessed state" do
-    @fsm = FSM::FSM.new
-    @fsm[:new_state].state.should eq(:new_state)
-    @fsm.state(:another_state).state.should eq(:another_state)
-    @fsm.state().state.should eq(:new_state)
-  end
-  
-end