simplefsm 0.2.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 838b9cda4f9f7b0f591b871cc616ca400ad394f6
+  data.tar.gz: ae9d5e7ec54dbfb8231dc60268badbcd886101c0
+SHA512:
+  metadata.gz: cd41f768c7adc8096bb0b996ab030d7e27dea9b317258eaec4b690462b65b985f787c665f20c0ed9de1f9b09c105ebebc229b53ab2edc9ca0746b88a1eb5e454
+  data.tar.gz: e540da439383cdd2b15becb409ca0e41ddad1d20ed8e3f34f450c2059470171acb2cb367e5cfabcf69ee24d3e6e147f0c22f3f63ca407d4b0b2d48f2c0267a3d

data/lib/simplefsm.rb

@@ -1,6 +1,5 @@
 # SimpleFSM - a DSL for finite state machines
 #
-# 
 # This module provides a domain specific language (DSL) that 
 # can be used to model a finite state machine (FSM) for any domain, 
 # including complex communication applications 
@@ -12,43 +11,54 @@
 # after the fsm keyword.
 #
 # Authors:: Edin Pjanic (mailto:edin.pjanic@untz.com), Amer Hasanovic (mailto:amer.hasanovic@untz.com)
-# License::   MIT License
+# License:: MIT License
 
 module SimpleFSM
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 
+  # TransitionFactory instance is a temporary helper object 
+  # for making transitions from a transitions_for code block parameter
+  class TransitionFactory
+    def initialize 
+      @transitions = []
+    end
+
+    def event ev, args
+      t = {:event => ev}.merge!(args)
+      @transitions << t
+    end
+
+    def transitions
+      @transitions
+    end
+  end
+
+  #Instance and class methods that are to be injected to the host class
   def initialize
-    @state ||=  {}
+    self.current_state =  {}
     super
   end
 
   # start the machine
   def run 
-    @state = @@states.first
-    if @state[:on]
-      send(@state[:on][:enter], nil) if @state[:on].has_key?(:enter)
+    self.current_state= @@states.first
+    if current_state[:on]
+      self.send(current_state[:on][:enter], nil) if current_state[:on].has_key?(:enter)
     end
   end
 
-  # get the current FSM state name
-  def state
-    @state[:state] #.to_sym
-  end
-
   # injecting the class methods for FSM definition
   def self.included klass
     klass.class_eval do
       @@states ||= []
       @@events ||= []
       @@transitions ||= {}
-      @@current_state_setup = nil
 
       def self.fsm (&block)
         instance_eval(&block)
 
         #Events methods definition
         # - one method is defined for every event specified
-
         @@events.each do |ev|
           Kernel.send :define_method, ev do |*args|
             fsm_prepare_state args
@@ -62,27 +72,27 @@ module SimpleFSM
               args = []
             end
 
-            if @state.class == Hash
-              st = @state[:state]
+            if current_state.class == Hash
+              st = current_state[:state]
             else
-              st = @state
+              st = current_state
             end
 
             statetrans = @@transitions[st]
             uniquestates = []
 
             if statetrans
-              # All transitions for this event in the current state
+              # Get all transitions for this event in the current state
               trans = statetrans.select{|t| !t.select{|k, v| k==:event and v == ev}.empty?} 
 
               if trans and trans.size>0
-                # The first transition that is triggered
+                # Index of the first transition that is triggered
                 index_triggered = trans.index do |v| 
                   # Guard specifiers:
                   # :guard      - all must be true
                   # :guard_not  - all must be false
                   # :guard_or   - at least one must be true
-                  # All guard specified specifiers must evaluate to true
+                  # All guard specifiers must evaluate to true
                   # in order for transition to be triggered.
                   guard_all = true
                   guards_and = []
@@ -101,18 +111,21 @@ module SimpleFSM
                     guards_not.flatten!
                   end
 
-                  guard_all &&= guards_and.all?   {|g| send(g, args) } if guards_and.size > 0
-                  guard_all &&= guards_or.any?    {|g| send(g, args) } if guards_or.size > 0
-                  guard_all &&= !guards_not.any?  {|g| send(g, args) } if guards_not.size > 0
+                  # TODO: think again about those guards
+                  guard_all &&= guards_and.all?   {|g| self.send(g, args) } if guards_and.size > 0
+                  guard_all &&= guards_or.any?    {|g| self.send(g, args) } if guards_or.size > 0
+                  guard_all &&= !guards_not.any?  {|g| self.send(g, args) } if guards_not.size > 0
                   guard_all
                 end 
                 if index_triggered
                   trans_triggered = trans[index_triggered] 
                   new_state = trans_triggered[:new] if trans_triggered.has_key?(:new)
 
-                  #START of :action keyword => call procs for event
+                  #START of :action keyword 
+                  # Call procs for the current event
                   # :do keyword - is not prefered 
                   # because it confuses source code editors
+                  # :action is a prefered one
                   action_keys = ['do'.to_sym, :action]
 
                   doprocs = []
@@ -121,7 +134,7 @@ module SimpleFSM
                   end
                   doprocs.flatten!
 
-                  doprocs.each {|p| send(p, args)} if doprocs.size > 0
+                  doprocs.each {|p| self.send(p, args)} if doprocs.size > 0
                   #END of :action keyword
 
                   do_transform new_state, args 
@@ -160,72 +173,56 @@ module SimpleFSM
         #add state in case it haven't been defined
         add_state_data sname 
 
-        erroneous_trans = trans.select{|a| !a.has_key?(:event) or !a.has_key?(:new)}
-
-        if !erroneous_trans.empty? 
-          raise "Error in transitions for :#{sname}." +
-              "Transition MUST contain keys :event and :new.\n" + 
-              "In: " + erroneous_trans.inspect
-              return
+        if block_given?
+          tf = TransitionFactory.new 
+          tf.send :define_singleton_method, :yield_block,  &block
+          tf.yield_block
+          trans << tf.transitions
+          trans.flatten!
         end
+        trans.each{ |t| check_transition t, sname }
 
         trans.each do |t|
-          if t.class != Hash 
-            raise "Error in transitions for :#{sname} in \'#{t.inspect}\'." +
-              "Transition must be a Hash Array."
-            return
-          end
-
-          add_transition sname, t
-
+          add_transition t, sname
           @@events << t[:event] if !@@events.any? { |e| t[:event] == e }
         end
 
-        # if events block is given
-        if block_given?
-          @@current_state_setup = sname
-          yield
-          @@current_state_setup = nil
-        end
+      end
 
+      # event keyword 
+      # returns transition that is to be added inside transitions_for method
+      def self.event ev, args #, &block
+        return {:event => ev}.merge!(args)
       end
 
-      # the event keyword 
-      def self.event ev, args
-        if !args or !args.is_a?(Hash)
-          raise "Error in event description for event: #{ev}." +
-              "Transition MUST be a Hash and at least MUST contain key :new.\n"  
-              return
+      ## Private class methods ######################
+      # Check whether given transition is valid
+      def self.check_transition tran, st='unknown'
+        ev = tran[:event] if tran.is_a?(Hash) and tran.has_key?(:event) 
+        ev ||= "unknown"
 
-        end
-        if !args.has_key?(:new) 
-          raise "Error in transitions for :#{sname}." +
-              "Transition MUST contain keys :event and :new.\n" + 
-              "In: " + erroneous_trans.inspect
-              return
-        end
-
-        t = {:event => ev}.merge!(args)
+        if !tran or !tran.is_a?(Hash) or !tran.has_key?(:event) or !tran.has_key?(:new) 
 
-        if !@@current_state_setup
-          t
-        else
-          add_transition @@current_state_setup, t
+          raise "Error in transition specification for event '#{ev}' of state '#{st}'.\n" +
+              "\t-> Transition MUST be a Hash and at least MUST contain both keywords 'event' and 'new'.\n"  +
+              "\t-> Transition data: #{tran}.\n"
+              return
         end
       end
 
-      ## private class methods ######################
-
       # Add transition to state's transitions if it does not exist
-      def self.add_transition st, t
+      def self.add_transition t, st
           if !@@transitions[st].any? {|v| v == t}
             @@transitions[st] << t
+
+            #add the state to @@states if it does not exist 
             add_state_data t[:new]
           end
 
           @@events << t[:event] if !@@events.any? { |e| t[:event] == e }
       end
       
+
       def self.add_state_data sname, data={:on=>nil}, overwrite=false
         return if !sname
         symname = sname.to_sym
@@ -237,19 +234,19 @@ module SimpleFSM
         end
       end
 
-
       private_class_method :fsm, :state, :transitions_for, :event
+      private_class_method :add_state_data , :add_transition, :check_transition
 
-      private_class_method :add_state_data, :add_transition
 
     end
   end
 
+  # Private instance methods
   private
 
   # perform transition from current to the next state
   def do_transform sname, args
-    # if new state is nil => don't change state
+    # if new state is nil then don't change state
     return if !sname
 
     symname = sname.to_sym
@@ -259,14 +256,15 @@ module SimpleFSM
       return
     end
 
-    onexit = @state[:on][:exit] if @state.has_key?(:on) and @state[:on] and @state[:on].has_key?(:exit)
+    # onexit, onenter = nil, nil
+    onexit = current_state[:on][:exit] if current_state.has_key?(:on) and current_state[:on] and current_state[:on].has_key?(:exit)
     if newstate[:on]
       onenter = newstate[:on][:enter] if newstate[:on].has_key?(:enter)
     end
 
-    send(onexit, args) if onexit
-    @state = newstate
-    send(onenter, args) if onenter
+    self.send(onexit, args) if onexit
+    self.current_state = newstate
+    self.send(onenter, args) if onenter
   end
 
   def fsm_responds_to? ev
@@ -281,31 +279,49 @@ module SimpleFSM
     get_state_events(st).any?{|e| e == ev}
   end
 
-  def get_state_events state
+  def get_state_events st
     ev = []
-    tr = @@transitions[state[:state]]
-    if tr 
-      ts = tr.each{|t| ev << t[:event]}
-      ev.uniq
-    else
-      []
-    end
+    tr = @@transitions[st[:state]]
+    ev << tr.map{|tran| tran[:event]} if tr
+    ev.uniq!
+    ev
   end
 
+  # PLEASE OVERRIDE  !
+  # ################################################################### 
   # The following methods should be overriden according to the application.
   #
   # They are called when any event is fired in order 
-  # to perform state loading/saving if the state is saved in
+  # to perform state loading/saving in case state is saved in
   # an external database or similar facility.
   #
-  # fsm_prepare_state method is called before and
-  # fsm_save_state method is called after
-  # actual state transition and all consequent actions. 
-  def fsm_prepare_state args
+  # #current_state is a private accessor that returns a full state object
+  # #state is a public method that returns only the sate's name
+  # #fsm_prepare_state method is called before and
+  # #fsm_save_state method is called after actual state transition and all consequent actions. 
+  
+  def current_state
     @state
   end
 
+  def current_state= (st)
+    @state = st
+  end
+
+  def state
+    current_state[:state] #.to_sym
+  end
+
+  def fsm_prepare_state args
+    current_state
+  end
+
   def fsm_save_state args
-    @state
+    current_state
   end
+
+  public :state
+  private :current_state, :current_state=
+  private :fsm_prepare_state, :fsm_save_state
+
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: simplefsm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease:
+  version: 0.2.1
 platform: ruby
 authors:
 - Edin Pjanic
 - Amer Hasanovic
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-22 00:00:00.000000000 Z
+date: 2017-04-16 00:00:00.000000000 Z
 dependencies: []
-description: A simple and lightweight domain specific language (DSL) for modeling finite state machines (FSM).
+description: A simple and lightweight domain specific language (DSL) for modeling
+  finite state machines (FSM).
 email:
 - edin@ictlab.com.ba
 - amer@ictlab.com.ba
@@ -23,7 +23,8 @@ files:
 - lib/simplefsm.rb
 homepage: http://github.com/edictlab/SimpleFSM
 licenses: []
-post_install_message:
+metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -31,20 +32,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
-  none: false
+      version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 1.8.24
-signing_key:
-specification_version: 3
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
 summary: SimpleFSM - a Ruby DSL for FSMs
 test_files: []