gviz 0.0.1

data/examples/examples.rb

@@ -0,0 +1,71 @@
+require_relative "../lib/gviz"
+
+simple = Gviz.new
+simple.graph do
+  route :main => [:init, :parse, :cleanup, :printf]
+  route :init => :make
+  route :parse => :execute
+  route :execute => [:make, :compare, :printf]
+end
+# simple.save(:a, :svg)
+
+enhanced = Gviz.new
+enhanced.graph do
+  route :main => [:init, :parse, :cleanup, :printf]
+  route :init => :make, :parse => :execute
+  route :execute => [:make, :compare, :printf]
+  node(:main, :shape => 'box')
+  node(:compare, :shape => 'box', :style => 'filled', :color => '.7 .3 1.0')
+  node(:make, :label => "make a\nstring")
+  edge(:main_printf, :style => 'bold', :label => "100 times", :color => 'red', :weight => 8)
+  edge(:main_parse, :weight => 8)
+  edge(:main_init, :style => "dotted")
+  edge(:execute_compare, :color => 'red')
+end
+# puts enhanced
+
+polygonal = Gviz.new
+polygonal.graph do
+  route :a => :b, :b => [:c, :d]
+  node(:a, :shape => 'polygon', :sides => 5, :peripheries => 3, :style => 'filled', :fillcolor => '#DA70D6')
+  node(:c, :shape => 'polygon', :sides => 4, :skew => 0.4, :label => "hellow world", :peripheries => 2, :orientation => 20, :fontname => 'Helvetica', :fontcolor => '#DA70D6')
+  node(:d, :shape => 'invtriangle')
+  node(:e, :shape => 'polygon', :style => 'setlinewidth(8)', :sides => 4, :distortion => 0.7)
+  edge(:b_d, :label => 'path to the world', :decorate => true, :labelfloat => true)
+  edge(:a_b, :dir => 'both', :headport => 'se')
+  edge(:a_b_1, :dir => 'back')
+  global(:rankdir => "TB", :rankseq => 'equally')
+end
+# puts polygonal
+
+record = Gviz.new
+record.graph do
+  nodes(:shape => 'record')
+  route :st1 => [:st2, :st3]
+  node(:st1, :label => "<f0> left|<f1> middle|<f2> right")
+  node(:st2, :label => "<f0> one|<f1> two")
+  node(:st3, :label => "hello\nworld|{b|{c|<here> d|e}|f}|g|h")
+  edge("st1:f1_st2:f0")
+  edge("st1:f2_st3:here")
+end
+# puts record
+
+sub = Gviz.new
+sub.graph do
+  subgraph do
+    nodes(style:'filled', color:'white')
+    global(style:'filled', color:'lightgrey', label:'process #1')
+    route(:a0 => :a1, :a1 => :a2, :a2 => :a3)
+  end
+
+  subgraph do
+    nodes(style:'filled')
+    global(color:'blue', label:'process #2')
+    route(:b0 => :b1, :b1 => :b2, :b2 => :b3)
+  end
+  route :start => [:a0, :b0]
+  route :a1 => :b3, :b2 => :a3, :a3 => [:a0, :end], :b3 => :end
+  node(:start, shape:'Mdiamond')
+  node(:end, shape:'Msquare')
+end
+# sub.save('a', 'png')

data/examples/scraper.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+require "nokogiri"
+require "open-uri"
+
+module Gviz
+  class Scraper
+    URL = "http://www.graphviz.org/content/"
+
+    class << self
+      def build(path)
+        @html ||= get(URL+path)
+        parse @html
+      end
+
+      def get(url)
+        @html = Nokogiri::HTML(open url)
+      rescue OpenURI::HTTPError => e
+        STDERR.puts "HTTP Access Error:#{e}"
+        exit
+      end
+
+      def parse(html)
+        q = []
+
+        # ## shapes
+        # html.css("div.content>table td>a").each do |a|
+        #   q << a.text
+        # end
+        # return q.uniq
+        
+        ## arrows
+        html.css("table").each_with_index do |tbl, i|
+          if i == 5
+            tbl.css("td").each do |e|
+              txt = e.text.strip.chomp
+              q << txt unless txt.empty?
+            end
+          end
+        end
+        return q.uniq
+
+        # ## X11 colors scheme
+        # table = html.at("div.content>table").css('td>a').each do |color|
+        #   txt = color.text.gsub(' ','')
+        #   q << txt unless txt.match(/^\d+$/)
+        # end
+        # return q.sort.uniq.group_by { |c| c[/^\D+/]; $& }
+        #         .flat_map { |k, v| v.sort_by { |c| c[/\d+/].to_i } }
+        
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # puts Gviz::Scraper.build("node-shapes")
+  puts Gviz::Scraper.build("arrow-shapes")
+  # puts Gviz::Scraper.build("color-names")
+end

data/examples/shape.dot

@@ -0,0 +1,108 @@
+digraph G {
+  node[style="filled",fillcolor="orchid"];
+  edge[arrowhead="none"];
+  box[shape="box"];
+  polygon[shape="polygon"];
+  ellipse[shape="ellipse"];
+  oval[shape="oval"];
+  circle[shape="circle"];
+  point[shape="point"];
+  egg[shape="egg"];
+  triangle[shape="triangle"];
+  plaintext[shape="plaintext"];
+  diamond[shape="diamond"];
+  trapezium[shape="trapezium"];
+  parallelogram[shape="parallelogram"];
+  house[shape="house"];
+  pentagon[shape="pentagon"];
+  hexagon[shape="hexagon"];
+  septagon[shape="septagon"];
+  octagon[shape="octagon"];
+  doublecircle[shape="doublecircle"];
+  doubleoctagon[shape="doubleoctagon"];
+  tripleoctagon[shape="tripleoctagon"];
+  invtriangle[shape="invtriangle"];
+  invtrapezium[shape="invtrapezium"];
+  invhouse[shape="invhouse"];
+  Mdiamond[shape="Mdiamond"];
+  Msquare[shape="Msquare"];
+  Mcircle[shape="Mcircle"];
+  rect[shape="rect"];
+  rectangle[shape="rectangle"];
+  square[shape="square"];
+  none[shape="none"];
+  note[shape="note"];
+  tab[shape="tab"];
+  folder[shape="folder"];
+  box3d[shape="box3d"];
+  component[shape="component"];
+  promoter[shape="promoter"];
+  cds[shape="cds"];
+  terminator[shape="terminator"];
+  utr[shape="utr"];
+  primersite[shape="primersite"];
+  restrictionsite[shape="restrictionsite"];
+  fivepoverhang[shape="fivepoverhang"];
+  threepoverhang[shape="threepoverhang"];
+  noverhang[shape="noverhang"];
+  assembly[shape="assembly"];
+  signature[shape="signature"];
+  insulator[shape="insulator"];
+  ribosite[shape="ribosite"];
+  rnastab[shape="rnastab"];
+  proteasesite[shape="proteasesite"];
+  proteinstab[shape="proteinstab"];
+  rpromoter[shape="rpromoter"];
+  rarrow[shape="rarrow"];
+  larrow[shape="larrow"];
+  lpromoter[shape="lpromoter"];
+  box -> polygon;
+  polygon -> ellipse;
+  ellipse -> oval;
+  oval -> circle;
+  circle -> point[headlabel="point"];
+  point -> egg;
+  egg -> triangle;
+  triangle -> plaintext;
+  plaintext -> diamond;
+  trapezium -> parallelogram;
+  parallelogram -> house;
+  house -> pentagon;
+  pentagon -> hexagon;
+  hexagon -> septagon;
+  septagon -> octagon;
+  octagon -> doublecircle;
+  doublecircle -> doubleoctagon;
+  doubleoctagon -> tripleoctagon;
+  invtriangle -> invtrapezium;
+  invtrapezium -> invhouse;
+  invhouse -> Mdiamond;
+  Mdiamond -> Msquare;
+  Msquare -> Mcircle;
+  Mcircle -> rect;
+  rect -> rectangle;
+  rectangle -> square;
+  square -> none;
+  note -> tab;
+  tab -> folder;
+  folder -> box3d;
+  box3d -> component;
+  component -> promoter;
+  promoter -> cds;
+  cds -> terminator;
+  terminator -> utr;
+  utr -> primersite;
+  restrictionsite -> fivepoverhang;
+  fivepoverhang -> threepoverhang;
+  threepoverhang -> noverhang;
+  noverhang -> assembly;
+  assembly -> signature;
+  signature -> insulator;
+  insulator -> ribosite;
+  ribosite -> rnastab;
+  rnastab -> proteasesite;
+  proteinstab -> rpromoter;
+  rpromoter -> rarrow;
+  rarrow -> larrow;
+  larrow -> lpromoter;
+}

data/examples/shapes.rb

@@ -0,0 +1,79 @@
+# Shape Varieties
+require_relative "../lib/gviz"
+
+shapes = DATA.lines.map(&:chomp).reject { |l| l.empty? }
+
+g = Gviz.new
+
+g.graph do
+  nodes(style:'filled', fillcolor:'orchid')
+  edges(arrowhead:'none')
+  shapes.each { |shape| node shape.intern, shape: shape }
+
+  shapes.each_slice(10) do |gr|
+    gr.each_cons(2) do |a, b|
+      route a.intern => b.intern
+    end
+  end
+  edge(:circle_point, headlabel:'point')
+end
+
+
+puts g
+
+__END__
+box
+polygon
+ellipse
+oval
+circle
+point
+egg
+triangle
+plaintext
+diamond
+trapezium
+parallelogram
+house
+pentagon
+hexagon
+septagon
+octagon
+doublecircle
+doubleoctagon
+tripleoctagon
+invtriangle
+invtrapezium
+invhouse
+Mdiamond
+Msquare
+Mcircle
+rect
+rectangle
+square
+none
+note
+tab
+folder
+box3d
+component
+promoter
+cds
+terminator
+utr
+primersite
+restrictionsite
+fivepoverhang
+threepoverhang
+noverhang
+assembly
+signature
+insulator
+ribosite
+rnastab
+proteasesite
+proteinstab
+rpromoter
+rarrow
+larrow
+lpromoter

data/gviz.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gviz/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "gviz"
+  gem.version       = Gviz::VERSION
+  gem.authors       = ["kyoendo"]
+  gem.email         = ["postagie@gmail.com"]
+  gem.description   = %q{Ruby's interface of graphviz}
+  gem.summary       = %q{Ruby's interface of graphviz. It generate a dot file with simple ruby's syntax. }
+  gem.homepage      = "https://github.com/melborne/Gviz"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/gviz.rb

@@ -0,0 +1,211 @@
+class Gviz
+  class Node < Struct.new(:id, :attrs)
+    def initialize(id, attrs={})
+      raise ArgumentError, "`id` must not include underscores" if id.match(/_/)
+      super
+    end
+
+    def to_s
+      "#{id}"
+    end
+  end
+
+  class Edge < Struct.new(:id, :attrs)
+    attr_reader :st, :ed, :seq, :st_port, :ed_port
+    def initialize(id, attrs={})
+      raise ArgumentError, "`attrs` must a hash" unless attrs.is_a?(Hash)
+      id, @st, @ed, @seq, @st_port, @ed_port = parse_id(id)
+      super(id, attrs)
+    end
+
+    def to_s
+      stp = ":#{st_port}" if st_port
+      edp = ":#{ed_port}" if ed_port
+      "#{st}#{stp} -> #{ed}#{edp}"
+    end
+
+    def nodes
+      [st, ed]
+    end
+
+    private
+    def parse_id(id)
+      st, ed, seq = "#{id}".split('_')
+      st, st_port = st.split(':').map(&:intern)
+      ed, ed_port = ed.split(':').map(&:intern)
+      id = (seq ? [st, ed, seq] : [st, ed]).join('_').intern
+      [id, st, ed, seq.to_i, st_port, ed_port]
+    end
+  end
+
+  attr_reader :gnode_attrs, :gedge_attrs, :graph_attrs, :subgraphs, :ranks
+  def initialize(name=:G, type=:digraph)
+    @name, @type = name, type
+    @edges = {}
+    @nodes = {}
+    @gnode_attrs = {}
+    @gedge_attrs = {}
+    @graph_attrs = {}
+    @subgraphs = []
+    @ranks = []
+  end
+  
+  def nodeset
+    @nodes.values
+  end
+
+  def edgeset
+    @edges.values
+  end
+
+  def node(id, attrs={})
+    raise ArgumentError, '`id` must a symbol' unless id.is_a?(Symbol)
+    Node[id, attrs].tap do |node|
+      if exist = @nodes[node.id]
+        exist.attrs.update(node.attrs)
+      else
+        @nodes.update(node.id => node)
+      end
+    end
+  end
+
+  def edge(id, attrs={})
+    unless id.match(/._./)
+      raise ArgumentError, '`id` must a symbol in which node names joined with "_"'
+    end
+    Edge[id.intern, attrs].tap do |edge|
+      if exist = @edges[id.intern]
+        exist.attrs.update(edge.attrs)
+      else
+        @edges.update(edge.id => edge)
+        create_nodes
+      end
+    end
+  end
+
+  def nodes(attrs)
+    @gnode_attrs.update(attrs)
+  end
+
+  def edges(attrs)
+    @gedge_attrs.update(attrs)
+  end
+
+  def global(attrs)
+    @graph_attrs.update(attrs)
+  end
+
+  def subgraph(&blk)
+    Gviz.new("cluster#{subgraphs.size}", :subgraph).tap do |graph|
+      subgraphs << graph
+      graph.instance_eval &blk
+    end
+  end
+  
+  def graph(&blk)
+    instance_eval(&blk)
+    self
+  end
+
+  def add(*nodes_or_routes)
+    nodes_or_routes.each do |unit|
+      case unit
+      when Hash
+        unit.each do |sts, eds|
+          Array(sts).product(Array(eds))
+                    .each { |st, ed| edge([st,ed].join('_').intern) }
+        end
+      when Symbol
+        node(unit)
+      else
+        raise ArgumentError, 'pass nodes in symbol or edges in hash'
+      end
+    end
+    self
+  end
+  alias :route :add
+
+  def rank(type, *nodes)
+    types = [:same, :min, :max, :source, :sink]
+    unless types.include?(type)
+      raise ArgumentError, "type must match any of #{types.join(', ')}"
+    end
+    @ranks << [type, nodes]
+  end
+
+  def to_s
+    result = []
+    tabs = "  "
+    result << "#{@type} #{@name} {"
+
+    unless graph_attrs.empty?
+      result << tabs + build_attrs(graph_attrs, false).join(";\n#{tabs}") + ";"
+    end
+
+    unless gnode_attrs.empty?
+      result << tabs + "node#{build_attrs(gnode_attrs)};"
+    end
+    
+    unless gedge_attrs.empty?
+      result << tabs + "edge#{build_attrs(gedge_attrs)};"
+    end
+    
+    @nodes.values.each do |node|
+      result << tabs + "#{node.id}#{build_attrs(node.attrs)};"
+    end
+
+    @edges.values.each do |edge|
+      result << tabs + "#{edge}#{build_attrs(edge.attrs)};"
+    end
+
+    subgraphs.each do |graph|
+      graph.to_s.lines do |line|
+        result << tabs + line.chomp
+      end
+    end
+
+    @ranks.each do |type, nodes|
+      result << tabs + "{ rank=#{type}; #{nodes.join('; ')}; }"
+    end
+    
+    result << "}\n"
+    result.join("\n")
+  end
+
+  def save(path, type=nil)
+    File.open("#{path}.dot", "w") { |f| f.puts self }
+    system "dot -T#{type} #{path}.dot -o #{path}.#{type}" if type
+  end
+  
+  private
+  def create_nodes
+    # only create unregistered nodes
+    ids = @edges.values.flat_map(&:nodes).uniq - @nodes.keys
+    ids.each { |id| node(id) }
+    @nodes
+  end
+
+  def build_attrs(attrs, join=true)
+    return nil if attrs.empty?
+    arr = attrs.map { |k, v| %(#{k}="#{v}").gsub("\n", "\\n") }
+    join ? '[' + arr.join(',') + ']' : arr
+  end
+end
+
+if __FILE__ == $0
+  g = Gviz.new
+  g.graph do
+    add(:main => [:printf, :parse, :init, :cleanup])
+    add(:parse => :execute, :init => :make)
+    add(:execute => [:printf, :compare, :make])
+    node(:main, :shape => 'box')
+    node(:make, :label => "make a\nstring")
+    node(:compare, :shape => 'box', :style => 'filled', :color => ".7 .3 1.0")
+    edge(:main_parse, :weight => 8)
+    edge(:main_init, :style => 'dotted')
+    edge(:main_printf, :style => 'bold', :label => "100 times", :color => 'red')
+    edge(:execute_compare, :color => 'red')
+  end
+  puts g
+end
+