wukong 3.0.0.pre → 3.0.0.pre2

data/lib/hanuman.rb

@@ -1,9 +1,36 @@
+require 'gorillib/some'
+require 'gorillib/model'
+require 'tsort'
 
-require 'gorillib/builder'
+require 'hanuman/registry'
+require 'hanuman/link'
+require 'hanuman/stage'              
+require 'hanuman/graph'
 
-require 'hanuman/stage'              # base object for building blocks
-require 'hanuman/slot'               # ports for inputs and outputs of stages
-require 'hanuman/slottable'          # modules that equip stages with input and output slots
-require 'hanuman/action'             # represents a transformation of resources
-require 'hanuman/resource'           # represents a resource
-require 'hanuman/graph'              # coordinates wukong stages
+module Hanuman
+  module Shortcuts
+    
+    def builder_shortcut(builder_type, label, *args, &blk)
+      if GlobalRegistry.registered?(label)
+        builder = GlobalRegistry.retrieve(label)
+      else
+        builder = builder_type.receive(label: label)
+      end
+      GlobalRegistry.decorate_with_registry(builder) if builder.is_a?(GraphBuilder)
+      builder.define(*args, &blk)
+    end
+    
+    def add_shortcut_method_for(method_name, builder_type)
+      self.define_singleton_method(method_name){ |label, *args, &blk| builder_shortcut(builder_type, label, *args, &blk) }
+    end
+
+    def registry() Hanuman::GlobalRegistry ; end    
+    
+  end
+
+  extend Hanuman::Shortcuts
+  
+  add_shortcut_method_for(:stage, StageBuilder)
+  add_shortcut_method_for(:graph, GraphBuilder)
+
+end

data/lib/hanuman/graph.rb

@@ -1,51 +1,75 @@
 module Hanuman
+  class Graph < Stage
+    include TSort
 
-  class Graph < Action
-    collection :stages, Hanuman::Stage, :doc => 'the sequence of stages on this graph', :key_method => :name
-    field      :edges,  Hash,           :doc => 'connections among all stages on the graph', :default => {}
-    include Hanuman::IsOwnInputSlot
-    include Hanuman::IsOwnOutputSlot
+    field :stages, Hash,  :default => {}
+    field :links,  Array, :default => []
+    
+    def tsort_each_node(&blk)
+      stages.keys.each(&blk)
+    end
 
-    def next_name_for(stage, basename=nil)
-      "#{basename || stage.class.handle}_#{stages.size}"
+    def tsort_each_child(node, &blk)
+      links.select{ |link| link.into == node }.map(&:from).each(&blk)
     end
 
-    def add_stage(stage)
-      stage.write_attribute(:name, next_name_for(stage)) if stage.name.nil?
-      stage.write_attribute(:owner, self)
-      stages << stage
-      stage
+    def directed_sort() self.tsort ; end
+  end
+
+  class GraphBuilder < StageBuilder
+    include TSort
+
+    field :stages, Hash,  :default => {}
+    field :links,  Array, :default => []
+
+    def define(&blk)     
+      graph = for_class || define_class(label) 
+      self.instance_eval(&blk) if block_given?
+      extract_links!
+      graph.register
     end
 
-    def connect(from_slot, into_slot)
-      from_slot = lookup(from_slot)
-      into_slot = lookup(into_slot)
-      actual_from_slot = from_slot.set_output(into_slot)
-      actual_into_slot = into_slot.set_input( from_slot)
-      #
-      edges[actual_from_slot] = actual_into_slot
-      [from_slot, into_slot]
+    def build(options = {})
+      attrs  = serialize
+      stages = attrs.delete(:stages).inject({}){ |hsh, (name, builder)| hsh[name] = builder.build(options) ; hsh }
+      for_class.receive attrs.merge(stages: stages)
     end
 
-    def lookup(ref)
-      ref.is_a?(Symbol) ? resource(ref) : ref
+    def namespace() Hanuman::Graph ; end
+
+    def handle_dsl_arguments_for(stage, *args, &blk)
+      options = args.extract_options!
+      stage.merge!(options)
+      stage
     end
 
-    def tree(options={})
-      super.merge( :stages => stages.to_a.map{|stage| stage.tree(options) } )
+    def extract_links!
+      stages.each_pair{ |name, builder| links << builder.links }
+      links.flatten!
+    end
+    
+    def serialize
+      attrs = attributes
+      args  = attrs.delete(:args)
+      attrs.delete(:for_class)
+      attrs.merge(args)      
     end
 
-    def graph(name, &block)
-      stage(name, :_type => Hanuman::Graph, &block)
+    def tsort_each_node(&blk)
+      stages.keys.each(&blk)
     end
 
-    def action(name, &block)
-      stage(name, :_type => Hanuman::Action, &block)
+    def tsort_each_child(node, &blk)
+      links.select{ |link| link.into == node }.map(&:from).each(&blk)
     end
 
-    def resource(name, &block)
-      stage(name, :_type => Hanuman::Resource, &block)
+    def directed_sort() self.tsort ; end
+
+    def clone
+      cloned_attrs  = Hash[ serialize.select{ |key, val| key != :stages }.map{ |key, val| dup_key = key.dup rescue key ; dup_val = val.dup rescue val ; [ dup_key, dup_val ] } ]
+      cloned_links  = links.map{ |link| link.dup }
+      cloned_stages = Hash[ stages.map{ |stage| stage.clone } ]
+      self.class.receive(cloned_attrs.merge(links: cloned_links).merge(stages: cloned_stages).merge(for_class: for_class))
     end
   end
-
 end

data/lib/hanuman/graphvizzer.rb

@@ -1,185 +1,206 @@
+require 'graphviz'
+  
 module Hanuman
-  module Graphvizzer
-    include Gorillib::Builder
-
-    class Item
-      include Gorillib::Builder
-      alias_method :configurate, :receive!
-
-      field :name,  Symbol
-      field :label, String, :default => ->{ name }
-      field :owner, Item
-
-      def initialize(attrs={}, &block)
-        receive!(attrs, &block)
-      end
-
-      def depth
-        owner.depth + 1
-      end
-
-      def indent(adj=0)
-        "  " * (depth + adj)
-      end
-
-      def quote(str)
-        return str if str.to_s.include?('"')
-        %Q{"#{str}"}
-      end
-
-      def line(str, attrs={}, term=';')
-        if attrs.empty?
-          attr_strs = ''
-        else
-          width = 40 - indent.length
-          str = "%-#{width}s" % str
-          attr_strs = attrs.map{|attr, val| attrib(attr, val) }
-          attr_strs = "[ #{attr_strs.join(",")} ]"
-        end
-        [indent, str, attr_strs, term].join
-      end
-
-      def attrib(attr, val)
-        "#{attr} = #{val}"
-      end
-
-      def brace(str)
-        "#{indent}#{str} {"
-      end
-      def close_brace
-        "#{indent}}"
-      end
-
-      def pad_with_attributes(text, attrs=nil)
-        width = 40 - (2 * graph.depth)
-        if attrs then
-          attr_strs = attrs.map{|attr, val| attribute_str(attr, val) }
-          "%-#{width}s [ %s ]" % [text, attr_strs.join(',')]
-        else
-          text
-        end
-      end
-    end
-
-    class Node < Item
-      field :inslots,  Array, :default => []
-      field :outslots, Array, :default => []
-      field :shape, Symbol, :default => :Mrecord
-
-      def graph_attribs
-        {
-          :shape => shape,
-          :label => quote(shape =~ /record/ ? structured_label : label),
-          # :fixedsize => true, :width => "1.0",
-        }
-      end
-
-      def inslots_str
-        inslots.map{|slot| "<#{slot}>#{slot[0..0]}"}.join("|")
-      end
-
-      def outslots_str
-        outslots.map{|slot| "<out_#{slot}>#{slot[0..0]}"}.join("|")
-      end
-
-      def label
-        super.to_s.gsub(/_\d+$/, '').gsub(/[_\.]+/, "\\n")
-      end
-
-      def structured_label
-        str = "{"
-        str << "{" << inslots_str << "}|"  unless inslots.empty?
-        str << label
-        str << "|{" << outslots_str << "}" unless outslots.empty?
-        str << "}"
-      end
-
-      def to_s
-        str = []
-        str << line(quote(name), graph_attribs)
-        str.join("\n")
-      end
-    end
+  class Graphvizzer
 
-    class Edge < Item
-      magic :from, String
-      magic :into, String
-
-      def to_s
-        str = ""
-        str << quote(from)
-        str << " -> "
-        str << quote(into)
-        line(str)
-      end
+    attr_accessor :hanuman_graph, :visual
+    
+    def initialize(hanuman_graph)
+      @hanuman_graph = hanuman_graph
+      @visual = GraphViz.new(@hanuman_graph.label, :type => :digraph)
     end
 
-    class Graph < Item
-      field :items, Array, :default => []
-      field :edges, Array, :default => []
-
-      def graph(name, attrs={})
-        obj = Graph.new(attrs.merge(:name => name, :owner => self))
-        items << obj
-        yield(obj) if block_given?
-        obj
-      end
-
-      def node(name, attrs={})
-        obj = Node.new(attrs.merge(:name => name, :owner => self))
-        items << obj
-        yield(obj) if block_given?
-        obj
-      end
-
-      def edge(from, into, from_slot=nil, into_slot=nil)
-        obj = Edge.new(
-          :name => name, :owner => self,
-          :from => from, :into => into,
-          :from_slot => from_slot, :into_slot => into_slot)
-        edges << obj
-        yield(obj) if block_given?
-        obj
-      end
-
-      def to_s
-        str = []
-        str << brace("subgraph #{quote("cluster_#{name}")}")
-        str << line(attrib("  label", quote(label)))
-        items.each do |item|
-          str << item.to_s
-        end
-        edges.each do |edge|
-          str << edge.to_s
-        end
-        str << close_brace
-        str.join("\n")
-      end
-    end
-
-    class Universe < Graph
-      field :orient, Symbol, :doc => 'one of :TB, :BT, :LR, :RL', :default => :TB
-      field :engine, Symbol, :default => :dot
-
-      def to_s
-        str = []
-        str << brace("digraph #{name}")
-        str << line("  rankdir = #{orient}")
-        items.each do |item|
-          str << item.to_s
-        end
-        str << close_brace
-        str.join("\n")
-      end
-
-      def depth() 0; end
-
-      def save(path, type=nil)
-        File.open "#{path}.dot", "w" do |f|
-          f.puts self.to_s
-        end
-        system "#{engine} -T#{type} #{path}.dot > #{path}.#{type}" if type
-      end
+    def create
+      hanuman_graph.directed_sort.each{ |stage| visual.add_nodes(stage.to_s) }
+      hanuman_graph.links.each{ |link| visual.add_edges(link.from.to_s, link.into.to_s) }
+      visual.output(:png => 'test.png')
     end
+  
   end
 end
+
+# module Hanuman
+#   module Graphvizzer
+#     include Gorillib::Builder
+
+#     class Item
+#       include Gorillib::Builder
+#       alias_method :configurate, :receive!
+
+#       field :name,  Symbol
+#       field :label, String, :default => ->{ name }
+#       field :owner, Item
+
+#       def initialize(attrs={}, &block)
+#         receive!(attrs, &block)
+#       end
+
+#       def depth
+#         owner.depth + 1
+#       end
+
+#       def indent(adj=0)
+#         "  " * (depth + adj)
+#       end
+
+#       def quote(str)
+#         return str if str.to_s.include?('"')
+#         %Q{"#{str}"}
+#       end
+
+#       def line(str, attrs={}, term=';')
+#         if attrs.empty?
+#           attr_strs = ''
+#         else
+#           width = 40 - indent.length
+#           str = "%-#{width}s" % str
+#           attr_strs = attrs.map{|attr, val| attrib(attr, val) }
+#           attr_strs = "[ #{attr_strs.join(",")} ]"
+#         end
+#         [indent, str, attr_strs, term].join
+#       end
+
+#       def attrib(attr, val)
+#         "#{attr} = #{val}"
+#       end
+
+#       def brace(str)
+#         "#{indent}#{str} {"
+#       end
+#       def close_brace
+#         "#{indent}}"
+#       end
+
+#       def pad_with_attributes(text, attrs=nil)
+#         width = 40 - (2 * graph.depth)
+#         if attrs then
+#           attr_strs = attrs.map{|attr, val| attribute_str(attr, val) }
+#           "%-#{width}s [ %s ]" % [text, attr_strs.join(',')]
+#         else
+#           text
+#         end
+#       end
+#     end
+
+#     class Node < Item
+#       field :inslots,  Array, :default => []
+#       field :outslots, Array, :default => []
+#       field :shape, Symbol, :default => :Mrecord
+
+#       def graph_attribs
+#         {
+#           :shape => shape,
+#           :label => quote(shape =~ /record/ ? structured_label : label),
+#           # :fixedsize => true, :width => "1.0",
+#         }
+#       end
+
+#       def inslots_str
+#         inslots.map{|slot| "<#{slot}>#{slot[0..0]}"}.join("|")
+#       end
+
+#       def outslots_str
+#         outslots.map{|slot| "<out_#{slot}>#{slot[0..0]}"}.join("|")
+#       end
+
+#       def label
+#         super.to_s.gsub(/_\d+$/, '').gsub(/[_\.]+/, "\\n")
+#       end
+
+#       def structured_label
+#         str = "{"
+#         str << "{" << inslots_str << "}|"  unless inslots.empty?
+#         str << label
+#         str << "|{" << outslots_str << "}" unless outslots.empty?
+#         str << "}"
+#       end
+
+#       def to_s
+#         str = []
+#         str << line(quote(name), graph_attribs)
+#         str.join("\n")
+#       end
+#     end
+
+#     class Edge < Item
+#       magic :from, String
+#       magic :into, String
+
+#       def to_s
+#         str = ""
+#         str << quote(from)
+#         str << " -> "
+#         str << quote(into)
+#         line(str)
+#       end
+#     end
+
+#     class Graph < Item
+#       field :items, Array, :default => []
+#       field :edges, Array, :default => []
+
+#       def graph(name, attrs={})
+#         obj = Graph.new(attrs.merge(:name => name, :owner => self))
+#         items << obj
+#         yield(obj) if block_given?
+#         obj
+#       end
+
+#       def node(name, attrs={})
+#         obj = Node.new(attrs.merge(:name => name, :owner => self))
+#         items << obj
+#         yield(obj) if block_given?
+#         obj
+#       end
+
+#       def edge(from, into, from_slot=nil, into_slot=nil)
+#         obj = Edge.new(
+#           :name => name, :owner => self,
+#           :from => from, :into => into,
+#           :from_slot => from_slot, :into_slot => into_slot)
+#         edges << obj
+#         yield(obj) if block_given?
+#         obj
+#       end
+
+#       def to_s
+#         str = []
+#         str << brace("subgraph #{quote("cluster_#{name}")}")
+#         str << line(attrib("  label", quote(label)))
+#         items.each do |item|
+#           str << item.to_s
+#         end
+#         edges.each do |edge|
+#           str << edge.to_s
+#         end
+#         str << close_brace
+#         str.join("\n")
+#       end
+#     end
+
+#     class Universe < Graph
+#       field :orient, Symbol, :doc => 'one of :TB, :BT, :LR, :RL', :default => :TB
+#       field :engine, Symbol, :default => :dot
+
+#       def to_s
+#         str = []
+#         str << brace("digraph #{name}")
+#         str << line("  rankdir = #{orient}")
+#         items.each do |item|
+#           str << item.to_s
+#         end
+#         str << close_brace
+#         str.join("\n")
+#       end
+
+#       def depth() 0; end
+
+#       def save(path, type=nil)
+#         File.open "#{path}.dot", "w" do |f|
+#           f.puts self.to_s
+#         end
+#         system "#{engine} -T#{type} #{path}.dot > #{path}.#{type}" if type
+#       end
+#     end
+#   end
+# end