simplificator-fsm 0.2.1 → 0.2.2

data/README.markdown

@@ -5,6 +5,7 @@ FSM is a simple finite state machine
 ## Usage
     class Water
       include FSM
+      # The state machine is specified as a block in define_fsm.
       define_fsm do
         # now define all the states
         # you can add :enter / :exit callbacks (callback can be a String, Symbol or Proc)
@@ -14,12 +15,12 @@ FSM is a simple finite state machine
         state(:liquid)
         state(:solid, :enter => :on_enter_solid, :exit => :on_exit_solid)
         
-        # define all valid transitions (name, from, to)
+        # define all valid transitions (arguments are name of transition, from state name, to state name)
         # you can define callbacks which are called only on this transition
-        transition(:heat, :solid, :liquid)
-        transition(:heat, :liquid, :gas)     # look mam.... two transitions with same name
-        transition(:cooldown, :gas, :liquid)
-        transition(:cooldown, :liquid, :solid)
+        transition(:heat_up, :solid, :liquid, :event => :liquified)
+        transition(:heat_up, :liquid, :gas)     # look mam.... two transitions with same name
+        transition(:cool_down, :gas, :liquid)
+        transition(:cool_down, :liquid, :solid)
         
         # define the attribute which is used to store the state (defaults to :state)
         state(:state_of_material)
@@ -27,6 +28,19 @@ FSM is a simple finite state machine
         # define the initial state (defaults to the first state defined - :gas in this sample)
         initial(:liquid)
       end
+      
+      private
+      # callbacks here...
+      def ...
     end
+    
+    # then you can call these methods
+    w = Water.new
+    w.heat  # the name of the transition is the name of the method
+    w.reachable_state_names
+    w.available_transition_names
+    w.cool_down # again... it's the name of the transition
+    w.state_of_material
+    
 ## Copyright
 Copyright (c) 2009 simplificator GmbH. See LICENSE for details.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 1
+:patch: 2

data/lib/fsm/builder.rb

@@ -16,6 +16,7 @@ module FSM
     def process(&block)
       raise ArgumentError.new('Block expected') unless block_given?
       self.instance_eval(&block)
+      @machine.build_transition_methods
       @machine
     end
     

data/lib/fsm/machine.rb

@@ -1,10 +1,11 @@
 module FSM
   class Machine
-    attr_accessor(:initial_state_name, :current_state_attribute_name, :states)
+    attr_accessor(:initial_state_name, :current_state_attribute_name, :states, :transitions)
     
     def initialize(target_class)
       @target_class = target_class
-      self.states = {}
+      self.states = []
+      self.transitions = []
       self.current_state_attribute_name = :state
     end
     
@@ -17,29 +18,24 @@ module FSM
     end
     
     def state(name, options = {})
-      raise "State is already defined: '#{name}'" if self.states[name]
-      self.states[name] = State.new(name, options)
+      raise "State is already defined: '#{name}'" if self.state_for_name(name, true)
+      self.states << State.new(name, options)
       self.initial_state_name=(name) unless self.initial_state_name
     end
     
     def initial_state_name=(value)
-      raise UnknownState.new("Unknown state '#{value}'. Define states first with state(name)") unless self.states[value]
+      raise UnknownState.new("Unknown state '#{value}'. Define states first with state(name)") unless self.state_for_name(value, true)
       @initial_state_name = value
     end
     
     def transition(name, from_name, to_name, options = {})
       raise ArgumentError.new("name, from_name and to_name are required") if name.nil? || from_name.nil? || to_name.nil?
-      raise UnknownState.new("Unknown source state '#{from}'") unless self.states[from_name]
-      raise UnknownState.new("Unknown target state '#{to}'") unless self.states[to_name]
-      
-      from_state = self.states[from_name]
-      to_state = self.states[to_name]
       
+      from_state = self.state_for_name(from_name)
+      to_state = self.state_for_name(to_name)
       transition = Transition.new(name, from_state, to_state, options)
       from_state.add_transition(transition)
-      
-      define_transition_method(name)
-      
+      self.transitions << transition
     end
     
     def self.get_current_state_name(target)
@@ -55,24 +51,45 @@ module FSM
     def reachable_states(target)
       reachables = []
       current_state_name = Machine.get_current_state_name(target)
-      self.states.map do |name, state|
+      self.states.map do |state|
         reachables += state.to_states if state.name == current_state_name
       end
       reachables
     end
     
     def available_transitions(target)
-      self.states[Machine.get_current_state_name(target)].transitions.values
+      current_state_name = Machine.get_current_state_name(target)
+      state = state_for_name(current_state_name)
+      state.transitions.values
+    end
+    
+    
+    def build_transition_methods
+      names = self.transitions.map() {|transition| transition.name}.uniq
+      names.each do |name|
+        define_transition_method(name)
+      end
+    end
+    
+    # Lookup a State by it's name
+    # raises ArgumentError if state can not be found unless quiet is set to true
+    def state_for_name(name, quiet = false)
+      state = self.states.detect() {|state| state.name == name}
+      raise ArgumentError.new("Unknonw state '#{name}'") unless quiet || state
+      state
     end
     
     private
     
+    # defines a transition method on the target class.
+    # this is the method triggering the state change.
+    #
     def define_transition_method(name)
       @target_class.instance_eval do
         define_method(name) do |*args|
           machine = Machine[self.class]
           from_name = Machine.get_current_state_name(self)
-          from_state = machine.states[from_name]
+          from_state = machine.state_for_name(from_name)
           
           entry = from_state.transitions.detect() {|to_name, tr| tr.name == name}
           transition = entry.last if entry
@@ -83,19 +100,7 @@ module FSM
           transition.fire_event(self, args)
           to_state.enter(self)
           Machine.set_current_state_name(self, to_state.name)
-          true
-          
-          
-          
-          #to_state = machine.states[to_name]
-          #transition = from_state.transitions[to_name]
-          #raise InvalidStateTransition.new("No transition defined from #{from_name} -> #{to_name}") unless transition
-          
-          #from_state.exit(self)
-          #transition.fire_event(self, args)
-          #to_state.enter(self)
-          #Machine.set_current_state_name(self, to_name)
-          #true # at the moment always return true ... as soon as we have guards or thelike this could be false as well 
+          true # at the moment always return true ... as soon as we have guards or thelike this could be false as well 
         end
       end
     end

data/lib/fsm/options.rb

@@ -12,6 +12,5 @@ module FSM
         end
       end 
     end
-    
   end
 end

data/test/transition_test.rb

@@ -2,37 +2,43 @@ require 'test_helper'
 
 class TransitionTest < Test::Unit::TestCase
   context 'Initializer' do
+    
+    
     should 'require name, from and to' do
+      bli_state = FSM::State.new('bli')
+      blo_state = FSM::State.new('blo')
       assert_raise(ArgumentError) do
         FSM::Transition.new(nil, nil, nil)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new('bla', nil, nil)
+        FSM::Transition.new(:name, nil, nil)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new(nil, 'bli', nil)
+        FSM::Transition.new(nil, bli_state, nil)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new(nil, nil, 'blo')
+        FSM::Transition.new(nil, nil, blo_state)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new('bli', 'bli', nil)
+        FSM::Transition.new(:name, bli_state, nil)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new(nil, 'blo', 'blo')
+        FSM::Transition.new(nil, blo_state, blo_state)
       end
       assert_raise(ArgumentError) do
-        FSM::Transition.new('blo', nil, 'bli')
+        FSM::Transition.new(:name, nil, bli_state)
       end
       
-      FSM::Transition.new('bla', 'bli', 'blo')
+      FSM::Transition.new(:name, bli_state, blo_state)
     end
     
     should 'allow only valid options' do
+      bli_state = FSM::State.new('bli')
+      blo_state = FSM::State.new('blo')
       assert_raise(ArgumentError) do
-        FSM::Transition.new('bla', 'bli', 'blo', :foo => 12)
+        FSM::Transition.new(:name, bli_state, blo_state, :foo => 12)
       end
-      FSM::Transition.new('bla', 'bli', 'blo', :event => :some)
+      FSM::Transition.new(:name, bli_state, blo_state, :event => :some)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simplificator-fsm
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - simplificator
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-18 00:00:00 -07:00
+date: 2009-05-19 00:00:00 -07:00
 default_executable: 
 dependencies: []