wukong 3.0.0.pre → 3.0.0.pre2

data/lib/hanuman/graphvizzer/gv_models.rb

@@ -0,0 +1,161 @@
+module Hanuman
+  module Graphvizzer
+
+    COL_1_WIDTH = 47
+
+    class Item
+      include Gorillib::Builder
+
+      field :name,  Symbol
+      field :label, String, :default => ->{ name }
+      field :owner, Item
+
+      def indent(adj=0)
+        "  " * (depth + adj)
+      end
+
+      def depth
+        owner.depth + 1
+      end
+
+      def quote(str)        str.to_s.include?('"') ? str : %Q{"#{str}"} ;  end
+      def attrib(attr, val) "#{attr}=#{val}"    ; end
+      def brace(str)        "#{indent}#{str} {" ; end
+      def close_brace()     "#{indent}}"        ; end
+
+      def line(str, attrs={}, term=';')
+        if attrs.empty?
+          attr_strs = ''
+        else
+          width = COL_1_WIDTH - indent.length
+          str = "%-#{width}s" % str
+          attr_strs = attrs.map{|attr, val| attrib(attr, val) }
+          attr_strs = "\t[ #{attr_strs.join(", ")} ]"
+        end
+        [indent, str, attr_strs, term].join
+      end
+    end
+
+    class Graph < Item
+      field :items, Array, :default => []
+      field :edges, Array, :default => []
+
+      def to_s
+        str = []
+        str   << brace("subgraph #{quote("cluster_#{name}")}") ## subgraph "cluster_crust" {
+        str   << line(attrib("  label", quote(label)))         ##   label="crust";
+        items.each do |item|                                   ##
+          str << item.to_s                                     ##   "cherry_pie.crust.small_bowl"        [ shape=Mrecord, label="{small\nbowl}" ];
+        end                                                    ##   "cherry_pie.crust.flour"             [ shape=Mrecord, label="{flour}" ];
+        edges.each do |edge|                                   ##
+          str << edge.to_s                                     ##   "cherry_pie.crust.small_bowl"        -> "cherry_pie.crust.add_to_4";
+        end                                                    ##   "cherry_pie.crust.flour"             -> "cherry_pie.crust.add_to_4";
+        str << close_brace                                     ## }
+        str.join("\n")
+      end
+
+      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
+    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}")         ## digraph Wukong {
+        str << line("  rankdir = #{orient}")    ##   rankdir = TB;
+        items.each do |item|                    ##   subgraph "cluster_cherry_pie" {
+          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
+
+    class Node < Item
+      field :inslots,  Array, :default => []
+      field :outslots, Array, :default => []
+      field :shape, Symbol, :default => :Mrecord
+
+      def to_s
+        line(
+          quote(name),                            ## "cherry_pie.crust.small_bowl"      [
+          :shape => shape,                        ##   shape=Mrecord,
+          :label => quote(structured_label),      ##   label="{{<in>sb}|small\nbowl}"
+          )                                       ## ];
+      end
+
+      def abbreviate(word)
+        word.to_s.
+          gsub(/-\d+$/,'').   # remove a trailing index (-0...)
+          split(/[\W_]+/).    # split into _ separated segment
+          reject(&:empty?).map{|str| str[0] }.join
+      end
+
+      def inslots_str
+        inslots.map{|slot|  "<#{slot}>#{abbreviate(slot)}"}.join("|")
+      end
+
+      def outslots_str
+        outslots.map{|slot| "<_#{slot}>#{abbreviate(slot)}"}.join("|")
+      end
+
+      def label
+        super.to_s.gsub(/_\d+$/, '').gsub(/[_\.]+/, "\\n")
+      end
+
+      def structured_label
+        return label unless shape =~ /record/
+        str = "{"
+        str << "{"  << (inslots.empty?  ? "<i>"  : inslots_str) << "}|"
+        str << label
+        str << "|{" << (outslots.empty? ? "<_o>" : outslots_str) << "}"
+        str << "}"
+        str
+      end
+    end
+
+    class Edge < Item
+      field :from, Whatever
+      field :into, Whatever
+
+      def to_s
+        width = COL_1_WIDTH - indent.length
+        "#{indent}%-#{width}s\t-> %-s;" % [ from, into ] ## "cherry_pie.crust.small_bowl" -> "cherry_pie.crust.add_to_4";
+      end
+    end
+
+  end
+end

data/lib/hanuman/graphvizzer/gv_presenter.rb

@@ -0,0 +1,97 @@
+require 'hanuman/graphvizzer/gv_models'
+
+module Hanuman
+
+  Stage.class_eval do
+    class_attribute :draw_shape
+    self.draw_shape = :record
+
+    def graphviz_id
+      graph_id
+    end
+
+
+    def gv_into_label() warn [self, self.class.ancestors]; %Q{"#{graphviz_id}":"i"}  ; end
+    def gv_from_label() warn [self, self.class.ancestors]; %Q{"#{graphviz_id}":"_o"} ; end
+
+    def to_graphviz(gv)
+      gv.node(self.graphviz_id,
+        :label    => name,
+        :shape    => draw_shape,
+        )
+    end
+  end
+
+  Product.class_eval do
+    self.draw_shape = :Mrecord
+  end
+
+  module ::Wukong::Universe
+    def to_graphviz
+      gv = Hanuman::Graphvizzer::Universe.new(:name => self.name)
+      @workflows.each_value do |workflow|
+        workflow.to_graphviz(gv)
+      end
+      @dataflows.each_value do |dataflow|
+        dataflow.to_graphviz(gv)
+      end
+      gv
+    end
+  end
+
+  Graph.class_eval do
+    self.draw_shape = :record
+
+    def to_graphviz(gv)
+      gv.graph(graphviz_id, :label => name) do |gv2|
+        inslots.each_value{|slot|  slot.to_graphviz(gv2) if slot.wired? }
+
+        stages.each_value{|stage|  stage.to_graphviz(gv2) }
+
+        outslots.each_value{|slot| slot.to_graphviz(gv2) if slot.wired? }
+        #
+        edges.each_value do |edge|
+          gv2.edge(edge[:from].gv_from_label, edge[:into].gv_into_label)
+        end
+      end
+    end
+  end
+
+  module Hanuman::Slottable
+    def to_graphviz(gv)
+      super.tap{|node| node.receive!(
+          :inslots  => inslots.to_a.map{|slot|  slot.name },
+          :outslots => outslots.to_a.map{|slot| slot.name },
+          ) }
+      end
+  end
+
+  module InputSlotted
+    def gv_into_label() %Q{"#{graphviz_id}":"i"}  ; end
+  end
+  module OutputSlotted
+    def gv_from_label() %Q{"#{graphviz_id}":"_o"} ; end
+  end
+
+  Slot.class_eval do
+    def to_graphviz(gv)
+      gv.node(self.graphviz_id, label: name, shape: :Mrecord)
+    end
+    def graphviz_id() (stage.is_a?(Hanuman::Graph)||stage.is_a?(Wukong::Universe)) ? graph_id : stage.graph_id ; end
+  end
+
+  InputSlot.class_eval do
+    def gv_into_label() %Q{"#{graphviz_id}":"#{name}"}  ; end
+    def to_graphviz(gv)
+      super.tap{|node| node.receive!(inslots: [name] )}
+    end
+  end
+
+  OutputSlot.class_eval do
+    def gv_from_label() %Q{"#{graphviz_id}":"_#{name}"} ; end
+    def to_graphviz(gv)
+      super.tap{|node| node.receive!(outslots: [name] )}
+    end
+  end
+
+end

data/lib/hanuman/link.rb

@@ -0,0 +1,35 @@
+module Hanuman
+  class LinkFactory
+
+    Registry = {
+      simple: ->(from_stage, *into_stage){ DirectedLink.new(from_stage, *into_stage) }
+    }
+    
+    class << self
+    
+      def connect(label, from_stage, *into_stage)
+        Registry[label].call(from_stage, *into_stage)
+      end
+      
+      def register(label, factory_method)
+        Registry[label] = factory_method
+      end
+
+    end    
+  end
+  
+  class DirectedLink
+
+    attr_accessor :from, :into
+    
+    def initialize(from, into)
+      @from = from
+      @into = into
+    end
+
+    def to_s
+      "#<#{self.class}(#{from.to_s} -> #{into.to_s})>"
+    end
+    
+  end
+end

data/lib/hanuman/registry.rb

@@ -0,0 +1,46 @@
+module Hanuman
+  class Registry
+
+    REGISTRY = {} unless defined? REGISTRY
+    
+    def create_or_update(label, builder)
+      create(label, builder) ? true : update(label, builder)
+    end
+
+    def create(label, builder)
+      return false if registered?(label)
+      REGISTRY[label] = builder
+      true
+    end
+    
+    def update(label, new_definition)
+      return false unless registered?(label)
+      REGISTRY[label].merge!(new_definition)
+      true
+    end
+
+    def registered?(label)
+      REGISTRY.keys.include? label
+    end
+
+    def retrieve(label)
+      REGISTRY[label].clone rescue nil
+    end
+    
+    def decorate_with_registry(graph_instance)
+      REGISTRY.each_pair do |label, definition|
+        graph_instance.define_singleton_method(label) do |*args, &blk|
+          builder = Hanuman::GlobalRegistry.retrieve(label)
+          builder = handle_dsl_arguments_for(builder, *args, &blk)
+          stages[builder.label] = builder
+        end
+      end
+    end
+    
+    def show()           REGISTRY.dup              ; end
+    def clear!()         REGISTRY.clear            ; end
+    def merge!(contents) REGISTRY.merge!(contents) ; end
+  end  
+  
+  GlobalRegistry = Registry.new unless defined? GlobalRegistry
+end

data/lib/hanuman/stage.rb

@@ -1,51 +1,95 @@
 module Hanuman
-  class Stage
-    include Gorillib::Builder
-    alias_method :configure, :receive!
-
-    magic      :name,    Symbol,         :doc => 'name for this stage; should be unique among other stages on its containing graph', :tester => true
-    field      :owner,   Whatever,       :doc => 'the graph this stage sits in'
-    magic      :doc,     String,         :doc => 'freeform description of this stage type'
+  module StageClassMethods
 
-    # @returns the stage, namespaced by the graph that owns it
-    def fullname
-      [owner.try(:fullname), name].compact.join('.')
+    def label() self.to_s.demodulize.underscore.to_sym ; end
+    
+    def builder
+      return @builder if @builder
+      set_builder(StageBuilder.new(label: label))
     end
-
-    def self.handle
-      Gorillib::Inflector.underscore(Gorillib::Inflector.demodulize(self.name))
+    
+    def set_builder(builder)
+      @builder = builder unless builder.nil?
+      builder.for_class = self
+      @builder
     end
+    
+    def register(new_label = nil)
+      builder.label = new_label || label
+      Hanuman::GlobalRegistry.create_or_update(new_label || label, builder)      
+      self
+    end
+  end    
+
+  class Stage
+    include Gorillib::Model
+    extend  StageClassMethods
 
-    #
-    # Methods
-    #
+    field :label, Symbol
+  end  
 
-    # Called after the graph is constructed, before the flow is run
-    def setup
+  class StageBuilder
+    include Gorillib::Model
+
+    field :args,      Hash,  :default => {}
+    field :for_class, Class
+    field :label,     Symbol
+    field :links,     Array, :default => []
+
+    def define(*args, &blk)
+      stage = for_class || define_class(label, *args)
+      stage.class_eval(&blk) if block_given?
+      stage.register
     end
 
-    # Called to signal the flow should stop. Close any open connections, flush
-    # buffers, stop supervised projects, etc.
-    def stop
+    def build(options = {})      
+      for_class.receive self.serialize.merge(options)
+    end
+    
+    def handle_extra_attributes(attrs)
+      args.merge!(attrs)
     end
+    
+    def merge!(other_builder = {})
+      attrs = other_builder.attributes rescue other_builder
+      self.receive!(attrs)
+      self
+    end
+    
+    def namespace(*args) Hanuman::Stage ; end
+ 
+    def define_class(name, *args)
+      klass   = namespace(*args).const_get(name.to_s.camelize, Class.new(namespace(*args))) rescue nil
+      klass ||= namespace(*args).const_set(name.to_s.camelize, Class.new(namespace(*args)))
+      klass.set_builder(self)
+      klass
+    end
+    
+    def linkable_name(direction) self.label ; end
 
-    def lookup(stage)
-      owner.lookup(stage)
+    def add_link(level, from, into)    
+      links << Hanuman::LinkFactory.connect(level, from, into)
     end
 
-    #
-    # Graph connections
-    #
+    def into(other_stage)
+      self.add_link(:simple, self.linkable_name(:in), other_stage.linkable_name(:out))
+      other_stage
+    end
+    alias_method :|, :into
 
-    def notify(msg)
-      true
+    def serialize()      
+      attrs = attributes
+      args  = attrs.delete(:args)
+      attrs.delete(:links) ; attrs.delete(:for_class)
+      attrs.merge(args)
     end
 
-    def report
-      self.attributes
+    # This is a hacky method to clone a Stage ; probably could be merged into serialize?
+    def clone
+      cloned_attrs = Hash[ serialize.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 }
+      self.class.receive(cloned_attrs.merge(links: cloned_links).merge(for_class: for_class))
     end
 
-    def to_key()      name   ; end
-    def key_method() :name ; end
   end
 end