fsm 0.0.0

data/lib/fsm-0.0.0/fsm.rb

@@ -0,0 +1,211 @@
+unless defined? $__fsm_fsm__
+  $__fsm_fsm__ = __FILE__ 
+
+  module FSM 
+    FSM::LIBDIR =
+      File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? FSM::LIBDIR
+
+    FSM::INCDIR =
+      File::dirname(FSM::LIBDIR) + File::SEPARATOR unless
+        defined? FSM::INCDIR
+
+    require INCDIR + 'fsm'
+
+    class  FSM
+      include Util
+
+      tattrs %w[
+        graph
+        state_attributes
+        state
+        subscribers
+        dsl
+      ]
+
+      def initialize *a, &b 
+        super
+
+        @graph = DirectedGraph.new
+        @state_attributes = Hash.new{|h,k| h[k] = Hash.new}
+
+        @graph.add_node 'start'
+        @state_attributes['start'].update 'shape' => 'point'
+        @state = 'start' 
+
+        @subscribers = [] 
+
+        states = a.flatten
+        states.each{|state| @graph.add_node state}
+
+        @dsl = DSL.new self
+        configure &b if b
+      end
+
+      def configure &b
+        ex{
+          @dsl.configure &b
+        }
+      end
+
+      def subscribe subscriber, event, *events
+        ex{
+          @subscriptions << Subscription.new(subscriber, event, *events)
+        }
+      end
+
+      def inspect
+        sh{
+          @graph.links.inspect
+        }
+      end
+
+      def start
+        transition 'start', 'start'
+      end
+      alias_method 'start!', 'start'
+
+      def add_observer o
+        ex{ @subscribers << o }
+      end
+
+      class TransitionError < ::StandardError; end
+
+      def transition state = nil, edge = nil, &b
+        validate_state = lambda do |state|
+          if state
+            raise TransitionError, "state == <#{ @state.inspect }> not <#{ state.inspect }>" unless
+              @state == state
+          end
+        end
+
+        validate_edge = lambda do |edge|
+          if edge
+            raise TransitionError, "no path <#{ state }> -->> <#{ edge }>" unless
+              @graph.links_from(state).map{|link| link.info}.include? edge
+          end
+        end
+
+        ex{
+          validate_state[state]
+          state ||= @state
+
+          validate_edge[edge]
+          edge ||= 'default'
+
+          notify Event::Exit
+
+          @state = [@state, edge]
+          notify Event::Transition
+
+          bcall b, *@state if b
+
+          begin
+            @state = @graph.transition *@state
+          rescue => e
+            m,c,b = e.message, e.class, e.backtrace.join("\n")
+            raise TransitionError, "#{ m } (#{ c })\n#{ b }"
+          end
+
+          notify Event::Entry
+
+          @state
+        }
+      end
+      alias_method 'transitioning', 'transition'
+
+      def notify type, *data
+        sh{
+          e = type::new @state, *data
+          @subscribers.each{|s| e.notify s}
+        }
+      end
+
+      def traverse *pairs
+        pairs.to_a.flatten!
+        raise ArgumentError, 'odd number of arguments' unless
+          pairs.size.modulo(2).zero?
+        ex{
+          string_list(*pairs).each_slice(2){|state, edge| transition state, edge}
+        }
+      end
+
+      def input *data
+        sh{
+          p data
+          notify Event::Input, *data
+        }
+      end
+
+      def add_state *states
+        ex{
+          string_list(states).each{|state| 
+            @graph.add_node state
+            case @graph.num_nodes
+              when 2
+                add_transition 'start', 'start' => state
+                @state_attributes[state].update 'shape' => 'doublecircle'
+              else
+                @state_attributes[state].update 'shape' => 'circle'
+            end
+          }
+          self
+        }
+      end
+
+      def add_transition *a, &b
+        ex{
+          hashes, argv = a.partition{|arg| Hash === arg} 
+          info = argv.shift || 'default'
+          raise ArgumentError, "too many argv in <#{ argv.inspect }>"  unless argv.empty?
+          raise ArgumentError, "too few transitions in <#{ hashes.inspect }>"  if hashes.empty?
+          transitions = hashes.inject({}){|t,h| t.update h}
+          transitions.each do |u,v|
+            @graph.add_link *string_list(u,v,info)
+            #add_transition_action u, info, &b if b
+          end
+          self
+        }
+      end
+
+      def plot dot_in = nil, dot_out = nil, fmt = 'jpg', &b
+        dot_in ||= 
+          (tmp = Tempfile.new("#{ Process.pid }-#{ Time.now.to_i }-#{ rand }")).path 
+        if tmp
+          tmp.puts to_dot
+          tmp.close
+        else
+          open(dot_in, 'w'){|f| f.puts to_dot}
+        end
+        dot_out = dot_in + '.' + fmt
+        cmd = "#{ DOT_CMD } -T#{ fmt } #{ dot_in } -o #{ dot_out }"
+        system cmd or raise "cmd <#{ cmd } failed with <#{ $?.exitstatus }>" 
+        dot_out
+      end
+
+      def to_dot
+        sh{
+          dot = @graph.to_dot
+          @state_attributes.each do |state, attributes|
+            dot.set_node_attributes state, attributes 
+          end
+          class << dot
+            def to_s(*a, &b) to_dot_specification(*a, &b) end
+          end
+          dot
+        }
+      end
+
+      def display
+        dot_out = plot
+        at_exit{ File.unlink dot_out rescue nil}
+        Thread.new{
+          Thread.current.abort_on_exception = true
+          cmd = "#{ DISPLAY_CMD } #{ dot_out } </dev/null >/dev/null 2>&1"
+          system cmd or raise "cmd <#{ cmd } failed with <#{ $?.exitstatus }>" 
+          File.unlink dot_out rescue nil
+        }
+      end
+    end # class FSM
+  end # module FSM
+end

data/lib/fsm-0.0.0/fsm.rb.bak

@@ -0,0 +1,366 @@
+unless defined? $__fsm_fsm__
+  module FSM 
+#--{{{
+    FSM::LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? FSM::LIBDIR
+
+    #require LIBDIR + 'util'
+    require 'fsm'
+
+    class  FSM
+#--{{{
+      include Util
+      include Sync_m
+      def sh(&b) synchronize(:SH, &b) end
+      def ex(&b) synchronize(:EX, &b) end
+
+      %w(
+        graph
+        state
+        state_attributes
+        entry_actions
+        exit_actions
+        transition_actions
+        input_actions
+        threadgroup
+      ).each{|a| attr_accessor a}
+
+      def initialize *a, &b 
+        sync_initialize
+
+        @graph = DirectedGraph.new
+        @state_attributes = Hash.new{|h,k| h[k] = Hash.new}
+        @entry_actions = Hash.new{|h,k| h[k] = []} 
+        @exit_actions = Hash.new{|h,k| h[k] = []} 
+        @transition_actions = Hash.new{|h,k| h[k] = Hash.new{|h2,k| h2[k] = []}}
+        @input_actions = Hash.new{|h,k| h[k] = []} 
+
+        @graph.add_node 'start'
+        @state_attributes['start'].update 'shape' => 'point'
+        @state = 'start' 
+        @threadgroup = ThreadGroup.new
+
+        states = a.flatten
+        states.each{|state| @graph.add_node state}
+
+        configure &b if b
+      end
+
+      def configure &block
+        ex{
+          DSL.new(self).configure &block
+        }
+      end
+
+      def add_state *states
+        ex{
+          string_list(states).each{|state| 
+            @graph.add_node state
+            case @graph.num_nodes
+              when 2
+                add_transition 'start', 'start' => state
+                @state_attributes[state].update 'shape' => 'doublecircle'
+              else
+                @state_attributes[state].update 'shape' => 'circle'
+            end
+          }
+          self
+        }
+      end
+
+      def add_transition *a, &b
+        ex{
+          hashes, argv = a.partition{|arg| Hash === arg} 
+          info = argv.shift || 'default'
+          raise ArgumentError, "too many argv in <#{ argv.inspect }>"  unless argv.empty?
+          raise ArgumentError, "too few transitions in <#{ hashes.inspect }>"  if hashes.empty?
+          transitions = hashes.inject({}){|t,h| t.update h}
+          transitions.each do |u,v|
+            @graph.add_link *string_list(u,v,info)
+            add_transition_action u, info, &b if b
+          end
+          self
+        }
+      end
+
+      def start
+        ex{
+          transition 'start'
+        }
+      end
+      alias_method 'start!', 'start'
+
+      def add_entry_action state, &block
+        ex{
+          @entry_actions[string(state)] << block
+          @entry_actions[string(state)].size - 1
+        }
+      end
+      def delete_entry_action state, index
+        ex{
+          @entry_actions[string(state)].delete_at index
+        }
+      end
+
+      def add_exit_action state, &block
+        ex{
+          @exit_actions[string(state)] << block
+          @exit_actions[string(state)].size - 1
+        }
+      end
+      def delete_exit_action state, index
+        ex{
+          @exit_actions[string(state)].delete_at index
+        }
+      end
+
+      def add_transition_action state, along, &block
+        ex{
+          @transition_actions[string(state)][string(along)] << block
+          @transition_actions[string(state)][string(along)].size - 1
+        }
+      end
+      def delete_transition_action state, index
+        ex{
+          @transition_actions[string(state)][string(along)].delete_at index
+        }
+      end
+
+      def add_input_action state, &block
+        ex{
+          @input_actions[string(state)] << block
+          @input_actions[string(state)].size - 1
+        }
+      end
+      def delete_input_action state, index
+        ex{
+          @input_actions[string(state)].delete_at index
+        }
+      end
+
+      def transition along = 'default' 
+        run = lambda{|table|
+          actions = Array === @state ? table[@state.first][@state.last] : table[@state]
+          actions.map{|action| bcall action, state}
+        }
+
+        ex{
+          state = @state
+          begin
+            run[@exit_actions]
+            @state = [@state, along]
+            run[@transition_actions]
+            @state = @graph.transition *@state
+            run[@entry_actions]
+            @state
+          rescue Exception => e
+            @state = state
+            raise
+          end
+        }
+      end
+      alias_method 'transitioning', 'transition'
+
+      def input *data
+        sh{
+          actions = @input_actions[@state]
+          actions.map do |action|
+            if bcall action, 'predicate', *data
+              bcall action, 'action', *data
+            end
+          end
+        }
+      end
+      
+      def traverse *a
+        ex{
+          string_list(*a).each{|along| transition along}
+        }
+      end
+
+      def add_thread t
+        t.abort_on_exception = true
+        ex{
+          @threadgroup.add t
+          t
+        }
+      end
+
+
+    #
+    # entry hooks 
+    #
+=begin
+      def wait_for_entry state, *a, &b
+        state, q, this = string(state), Queue.new, self
+        ex{
+          index =
+            add_input_action(state) do
+              add_entry_action(state){ q.push state }
+            end
+          add_thread Thread.new(*a){|*a|
+            begin
+              bcall b, q.pop, *a
+            ensure
+              this.delete_entry_action state, index
+            end
+          }
+        }
+      end
+      alias_method 'wait_for', 'wait_for_entry'
+      def on_entry state, *a, &b
+        state, q = string(state), Queue.new
+        ex{
+          add_entry_action(state){ q.push state }
+          add_thread Thread.new(*a){|*a| loop{ bcall b, q.pop, *a } }
+        }
+      end
+=end
+      def on_entry state, *a, &b
+        state = string(state)
+        ex{
+          add_entry_action(state){ bcall b, *a }
+        }
+      end
+      def once_on_entry state, *a, &b
+        index =
+          on_entry(state, *a) do
+            delete_entry_action state, index
+          end
+      end
+
+    #
+    # exit hooks
+    #
+      def wait_for_exit state, *a, &b
+        state, q, this = string(state), Queue.new, self
+        ex{
+          index =
+            add_input_action(state) do
+              add_exit_action(state){ q.push state }
+            end
+          add_thread Thread.new(*a){|*a|
+            begin
+              bcall b, q.pop, *a
+            ensure
+              this.delete_exit_action state, index
+            end
+          }
+        }
+      end
+      def on_exit state, *a, &b
+        state, q = string(state), Queue.new
+        ex{
+          add_exit_action(state){ q.push state }
+          add_thread Thread.new(*a){|*a| loop{ bcall b, q.pop, *a } }
+        }
+      end
+
+    #
+    # transition hooks
+    #
+      def wait_for_transition state, along, *a, &b
+        state, q, this = string(state), Queue.new, self
+        ex{
+          index =
+            add_input_action(state) do
+              add_transition_action(state){ q.push state and q.push along }
+            end
+          add_thread Thread.new(*a){|*a|
+            begin
+              bcall b, q.pop, q.pop, *a
+            ensure
+              this.delete_transition_action state, index
+            end
+          }
+        }
+      end
+      def on_transition state, along, *a, &b
+        state, q = string(state), Queue.new
+        ex{
+          add_transition_action(state){ q.push state and q.push along }
+          add_thread Thread.new(*a){|*a| loop{ bcall b, q.pop, q.pop, *a } }
+        }
+      end
+
+    #
+    # input hooks
+    #
+      def wait_for_input state, *a, &b
+        state, q, this = string(state), Queue.new, self
+        ex{
+          index =
+            add_input_action(state) do |mode, *data| 
+              mode =~ %r/predicate/ ? true : (q.push(state); q.push(data))
+            end
+          add_thread Thread.new(*a){|*a|
+            begin
+              bcall b, q.pop, *(a + q.pop)
+            ensure
+              this.delete_input_action state, index
+            end
+          }
+        }
+      end
+      def on_input state, *a, &b
+        state, q = string(state), Queue.new
+        ex{
+          add_input_action(state) do |mode, *data| 
+            mode =~ %r/predicate/ ? true : (q.push(state); q.push(data))
+          end
+          add_thread Thread.new(*a){|*a| loop{ bcall b, q.pop, *(a + q.pop) } }
+        }
+      end
+
+
+
+      def join
+        loop{
+          #p sh{ @threadgroup.list }
+          if sh{ @threadgroup.list }.empty?
+            break
+          else
+            sleep 0.42 
+          end
+        }
+        self
+      end
+
+
+# rotate text!
+      def plot fmt = 'png', dot_in = nil, dot_out = nil
+        sh{
+          dot_in ||= Tempfile.new("#{ Process.pid }-#{ Time.now.to_i }-#{ rand }").path 
+          open(dot_in, 'w') do |f| 
+            dot = @graph.to_dot
+            @state_attributes.each do |state, attributes|
+              dot.set_node_attributes state, attributes 
+            end
+            dot.orientation = 'landscape'
+            f.puts dot.to_dot_specification
+          end
+          dot_out = dot_in + '.' + fmt
+          cmd = "#{ DOT_CMD } -T#{ fmt } #{ dot_in } -o #{ dot_out }"
+          system cmd or raise "cmd <#{ cmd } failed with <#{ $?.exitstatus }>" 
+          dot_out
+        }
+      end
+
+      def display
+        sh{
+          dot_out = plot
+          Thread.new{
+            #Thread.current.abort_on_exception = true
+            cmd = "#{ DISPLAY_CMD } #{ dot_out } </dev/null >/dev/null 2>&1"
+            system cmd or raise "cmd <#{ cmd } failed with <#{ $?.exitstatus }>" 
+            at_exit{ File.unlink dot_out }
+            dot_out
+          }
+        }
+      end
+#--}}}
+    end # class FSM
+#--}}}
+  end # module FSM
+$__fsm_fsm__ = __FILE__ 
+end