fsm 0.0.0

data/lib/fsm-0.0.0/graph/graphviz_dot.rb

@@ -0,0 +1,188 @@
+class DotGraphPrinter
+  attr_accessor :orientation, :size, :color
+
+  # The following can be set to blocks of code that gives a default
+  # value for the node shapes, node labels and link labels, respectively.
+  attr_accessor :node_shaper, :node_labeler, :link_labeler
+
+  # A node shaper maps each node to a string describing its shape.
+  # Valid shapes are: 
+  #   "ellipse"   (default)
+  #   "box"
+  #   "circle"
+  #   "plaintext" (no outline)
+  #   "doublecircle"
+  #   "diamond"
+  # Not yet supported or untested once are:
+  #   "polygon", "record", "epsf"
+  @@default_node_shaper = proc{|n| "box"}
+
+  @@default_node_labeler = proc{|n| 
+    if Symbol===n
+      n.id2name 
+    elsif String===n
+      n
+    else
+      n.inspect
+    end
+  }
+
+  @@default_link_labeler = proc{|info| info ? info.inspect : nil}
+
+  # links is either array of 
+  #                   arrays [fromNode, toNode [, infoOnLink]], or
+  #                   objects with attributes :from, :to, :info
+  # nodes is array of node objects
+  # All nodes used in the links are used as nodes even if they are not 
+  # in the "nodes" parameters.
+  def initialize(links = [], nodes = [])
+    @links, @nodes = links, add_nodes_in_links(links, nodes)
+    @node_attributes, @edge_attributes = Hash.new, Hash.new
+    set_default_values
+  end
+
+  def set_default_values
+    @color = "black"
+    @size = "9,11"
+    @orientation = "portrait"
+    @node_shaper = @@default_node_shaper
+    @node_labeler = @@default_node_labeler
+    @link_labeler = @@default_link_labeler
+  end
+
+  def write_to_file(filename, fileType = "ps")
+    dotfile = temp_filename(filename)
+    File.open(dotfile, "w") {|f| f.write to_dot_specification}
+    system "dot -T#{fileType} -o #{filename} #{dotfile}"
+    File.delete(dotfile)
+  end
+
+  def set_edge_attributes(anEdge, aHash)
+    # TODO check if attributes are valid dot edge attributes
+    edge = find_edge(anEdge)
+    set_attributes(edge, @edge_attributes, true, aHash)
+  end
+
+  def set_node_attributes(aNode, aHash)
+    # TODO check if attributes are valid dot node attributes
+    set_attributes(aNode, @node_attributes, true, aHash)
+  end
+
+  def to_dot_specification
+    set_edge_labels(@links)
+    set_node_labels_and_shape(@nodes)
+    "digraph G {\n" +
+      graph_parameters_to_dot_specification +
+      @nodes.uniq.map {|n| format_node(n)}.join(";\n") + ";\n" +
+      @links.uniq.map {|l| format_link(l)}.join(";\n") + ";\n" +
+      "}"
+  end
+
+  protected
+
+  def find_edge(anEdge)
+    @links.each do |link|
+      return link if source_and_dest(link) == source_and_dest(anEdge)
+    end
+  end
+
+  def set_attributes(key, hash, override, newAttributeHash)
+    h = hash[key] || Hash.new
+    newAttributeHash = all_keys_to_s(newAttributeHash) 
+    newAttributeHash.each do |k, value|
+      h[k] = value unless h[k] and !override
+    end
+    hash[key] = h
+  end
+
+  def graph_parameters_to_dot_specification
+    "graph [\n" + 
+      (self.size ? "  size = #{@size.inspect},\n" : "") +
+      (self.orientation ? "  orientation = #{@orientation},\n" : "") +
+      (self.color ? "  color = #{@color}\n" : "") +
+    "]\n"
+
+    <<-dot_spec
+      graph[
+        rankdir = LR
+      ]
+    dot_spec
+  end
+
+  def each_node_in_links(links)
+    links.each do |l|
+      src, dest = source_and_dest(l)
+      yield src
+      yield dest
+    end
+  end
+
+  def add_nodes_in_links(links, nodes)
+    new_nodes = []
+    each_node_in_links(links) {|node| new_nodes.push node}
+    (nodes + new_nodes).uniq
+  end
+
+  def all_keys_to_s(aHash)
+    # MAYBE reuse existing hash?
+    Hash[*(aHash.map{|p| p[0] = p[0].to_s; p}.flatten)]
+  end
+
+  def set_edge_labels(edges)
+    edges.each do |edge|
+      src, dest, info = get_link_data(edge)
+      if info
+	label = @link_labeler.call(info)
+	set_attributes(edge, @edge_attributes, false, :label =>label) if label 
+      end
+    end
+  end
+
+  def set_node_labels_and_shape(nodes)
+    nodes.each do |node|
+      set_attributes(node, @node_attributes, false,
+		     :label => @node_labeler.call(node).inspect,
+		     :shape => @node_shaper.call(node).inspect)
+    end
+  end
+
+  def get_link_data(link)
+    begin
+      return link.from, link.to, link.info
+    rescue Exception
+      return link[0], link[1], link[2]
+    end
+  end
+  
+  def source_and_dest(link)
+    get_link_data(link)[0,2]
+  end
+
+  def format_attributes(attributes)
+    return "" unless attributes
+    strings = attributes.map {|a, v| "#{a}=#{v}"}
+    strings.length > 0 ? (" [" + strings.join(", ") + "]") : ("")
+  end
+
+  def mangle_node_name(node)
+    "n" + node.hash.abs.inspect
+  end
+
+  def format_link(link)
+    from, to, info = get_link_data(link)
+    mangle_node_name(from) + " -> " + mangle_node_name(to) + 
+      format_attributes(@edge_attributes[link])
+  end
+
+  def format_node(node)
+    mangle_node_name(node) + format_attributes(@node_attributes[node])
+  end
+
+  def temp_filename(base = "tmp")
+    tmpfile = base + rand(100000).inspect
+    while test(?f, tmpfile)
+      tmpfile = base + rand(100000).inspect
+    end
+    tmpfile
+  end
+end

data/lib/fsm-0.0.0/observer.rb

@@ -0,0 +1,194 @@
+unless defined? $__fsm_observer__
+  $__fsm_observer__ = __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 Observer
+      include Util
+
+      ANY = const 'ANY' 
+
+      tattrs %w[
+        fsm
+        hooks
+        q
+        thread
+        dsl
+      ]
+
+      def initialize fsm, &b
+        sync_initialize
+
+        @fsm = fsm
+        @fsm.add_observer self
+
+        @hooks = Hash.new{|etype_h, etype|
+          etype_h[etype] = Hash.new{|fstate_h, fstate|
+            fstate_h[fstate] = Array.new
+          }
+        }
+
+        @q = Queue.new
+
+        @thread = Thread.new{
+          Thread.current.abort_on_exception = true
+          loop{
+            b, *a = @q.pop
+            break unless b
+            bcall b, *a
+          }
+        }
+
+        @dsl = DSL.new self
+        configure &b if b
+      end
+
+      def configure &b
+        ex{
+          @dsl.configure &b
+        }
+      end
+
+      def defer hook, *a 
+        ex{
+          @q.push [hook, *a]
+        }
+      end
+
+      def idefer hook, *a 
+        ihook = lambda{|*a| instance_exec *a, &hook }
+        defer ihook, *a
+      end
+
+      def on etype = Event::Any, fstate = ANY, &hook
+        ex{
+          idx = (@hooks[etype][fstate] << hook).size - 1
+        }
+      end
+
+      def on_entry *a, &b 
+        on Event::Entry, *a, &b
+      end
+
+      def on_transition *a, &b 
+        on Event::Transition, *a, &b
+      end
+
+      def on_exit *a, &b 
+        on Event::Exit, *a, &b
+      end
+
+      def on_input *a, &b 
+        on Event::Input, *a, &b
+      end
+
+      module Once; end
+
+      def once_on etype = Event::Any, fstate = ANY, &hook
+        on etype, fstate, &hook.extend(Once)
+      end
+
+      def once_on_entry *a, &b
+        once_on Event::Entry, *a, &b
+      end
+
+      def once_on_transition *a, &b
+        once_on Event::Transition, *a, &b
+      end
+
+      def once_on_exit *a, &b
+        once_on Event::Exit, *a, &b
+      end
+
+      def once_on_input *a, &b
+        once_on Event::Input, *a, &b
+      end
+
+      def wait_for_entry fstate, &hook
+        argv = [fstate]
+        unless fsm.state == fstate
+          q = Queue.new
+          once_on(Event::Entry, fstate){|*a| q.push a }
+          argv.replace q.pop
+        end
+        icall hook, *argv if hook
+      end
+      alias_method 'wait_for', 'wait_for_entry'
+
+      def wait_for_transition fstate, &hook
+        argv = [fstate]
+        unless fsm.state == fstate
+          q = Queue.new
+          once_on(Event::Transition, fstate){|*a| q.push a }
+          argv.replace q.pop
+        end
+        icall hook, *argv if hook
+      end
+
+      def wait_for_exit fstate, &hook
+        argv = [fstate]
+        unless fsm.state == fstate
+          q = Queue.new
+          once_on(Event::Exit, fstate){|*a| q.push a }
+          argv.replace q.pop
+        end
+        icall hook, *argv if hook
+      end
+
+      def wait_for_input fstate, &hook
+        argv = [fstate]
+        unless fsm.state == fstate
+          q = Queue.new
+          once_on(Event::Input, fstate){|*a| q.push a }
+          argv.replace q.pop
+        end
+        icall hook, *argv if hook
+      end
+
+      def fsm_event event
+        ex{
+          [event.type, Event::Any].each do |etype|
+            [event.state, ANY].each do |estate|
+              #@hooks[etype][estate].each{|hook| idefer hook, event}
+              hooks = [] 
+              while((hook = @hooks[etype][estate].shift))
+                idefer hook, event
+                hooks.push hook unless hook.is_a? Once
+              end
+              @hooks[etype][estate].replace hooks
+            end
+          end
+        }
+      end
+
+      def join
+        @thread.join
+      end
+
+      def kill 
+        @thread.kill
+      end
+
+      alias_method 'stop', 'kill'
+
+      delegate %w[
+        start
+        transition
+        input
+        display
+        plot
+        state
+      ] => '@fsm'
+
+    end # class Observer
+  end # module FSM
+end

data/lib/fsm-0.0.0/system.rb

@@ -0,0 +1,65 @@
+unless defined? $__fsm_system__
+  $__fsm_system__ = __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 System
+      include Util
+
+      %w[
+        fsm
+        observer
+      ].each{|a| attr a}
+
+      def initialize fsm = FSM.new, &b
+        @fsm = fsm
+        @observer = Observer.new @fsm
+        @dsl = DSL.new self 
+        configure &b if b
+      end
+
+      def configure &b
+        @dsl.configure &b
+      end
+
+      delegate %w[
+        graph
+        state_attributes
+        state
+        subscribers
+        subscribe
+        inspect
+        start
+        add_observer
+        transition
+        traverse
+        input
+        add_state
+        add_transition
+        plot
+        to_dot
+        display
+      ] => '@fsm'
+
+      delegate %w[
+        on
+        on_entry
+        on_transition
+        on_exit
+        on_input
+        join
+        kill
+        stop
+      ] => '@observer'
+    end # class System
+  end # module FSM
+end

data/lib/fsm-0.0.0/util.rb

@@ -0,0 +1,172 @@
+unless defined? $__fsm_util__
+  $__fsm_util__ = __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'
+
+    module  Util
+      class Const
+        def self.new s 
+          s = s.to_s
+          (@instances ||= {})[s] ||= super(s)
+        end
+
+        attr 'to_s'
+        alias_method 'to_str', 'to_s'
+        alias_method 'inspect', 'to_s'
+
+        def initialize s 
+          @to_s = s.to_s 
+          freeze
+        end
+      end
+
+      module Methods
+        include Sync_m
+
+        def const(*a)
+          Const.new(*a)
+        end
+
+        def string_list *list
+          list.flatten.map{|elem| elem.to_s}
+        end
+
+        def string *list
+          string_list(*list).first
+        end
+
+        def klass
+          self.class
+        end
+
+        def bcall b, *a
+          arity = b.arity
+          if arity > 0
+            a = a[0...arity]
+          elsif arity < 0
+            arity = arity.abs
+            a = a[0...arity] + (a[arity..-1] || [])
+          else
+            a.clear
+          end
+          b.call *a
+        end
+
+        def mcall obj, msg, *a
+          m = obj.method(msg).to_proc
+          bcall m, *a
+        end
+
+        def icall b, *a
+          arity = b.arity
+          if arity > 0
+            a = a[0...arity]
+          elsif arity < 0
+            arity = arity.abs
+            a = a[0...arity] + (a[arity..-1] || [])
+          else
+            a.clear
+          end
+          instance_exec *a, &b
+        end
+
+        def system *a, &b
+          verbose = $VERBOSE
+          $VERBOSE = nil
+          ::Kernel.system *a, &b
+        ensure
+          $VERBOSE = verbose
+        end
+
+        unless instance_methods.include? 'instance_exec'
+          def instance_exec *a, &b
+            m, n = nil, -1 
+            loop{
+              m = "__instance_exec_#{ Thread.current.object_id.abs }_#{ n += 1 }__"
+              break unless respond_to? m
+            }
+            singleton_class{ define_method m, &b  }
+            send m, *a
+          ensure
+            singleton_class{ undef_method m  }
+          end
+        end
+
+        unless instance_methods.include? 'singleton_class'
+          def singleton_class &b
+            sc = 
+              class << self; self; end
+            sc.module_eval &b if b
+            sc
+          end
+        end
+
+        def sh(&b) synchronize(:SH, &b) end
+        def ex(&b) synchronize(:EX, &b) end
+
+
+        def initialize(*a, &b)
+          sync_initialize
+        end
+        alias_method 'sync_init', 'sync_initialize'
+
+      end
+
+      module ClassMethods
+        include Methods
+
+        def tattrs *ms
+          ms.flatten.each do |m|
+            module_eval <<-code
+              def #{ m }(*a, &b)
+                if a.empty?
+                  sh{ @#{ m } }
+                else
+                  self.#{ m }= a.shift
+                end
+              end
+              alias_method '#{ m }?', '#{ m }'
+              def #{ m }= val
+                ex{ @#{ m } = val }
+              end
+            code
+          end
+        end
+        alias_method 'tattr', 'tattrs'
+
+        def delegate hash = {} 
+          methods, to = hash.to_a.first
+          methods.each do |m|
+            module_eval <<-code
+              def #{ m } *a, &b
+                #{ to }.#{ m } *a, &b
+              end
+            code
+          end
+        end
+      end
+
+      module InstanceMethods
+        include Methods
+      end
+
+      def self.included other
+        other.extend ClassMethods
+        other.module_eval{ 
+          include InstanceMethods 
+          include Sync_m
+        }
+        super
+      end
+    end # module Util
+  end # module FSM
+end