GraphvizR 0.4.0 → 0.5.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.5.0 / 2007-03-11
+
+* remove all deprecated code
+* refactoring totally 
+* preserve the original order of creation of nodes and edges
+
 == 0.4.0 / 2007-02-26
 
 * default attributes for edge can be specified

data/lib/graphviz_r.rb

@@ -140,364 +140,53 @@
 #     c -> d [ltail = cluster0];
 #     c -> f [lhead = cluster1];
 #
-class GraphvizR
-  VERSION = '0.4.0'
+class GraphvizR 
+  VERSION = '0.5.0'
   INDENT_UNIT = '  '
 
-  # This represents graphviz attributes.
-  class Attributes 
-    def initialize(name, dot)
-      @name = name
-      @dot = dot
-    end
-
-    def [](attr)
-      @dot.send :"#{@name}=", attr
-    end
-  end
-
-  # This represents graphviz node.
-  class Node
-    attr_reader :attr, :name
-
-    def initialize(name, port, dot)
-      @name = name
-      @port = port || []
-      @dot = dot
-      @attr = {}
-
-      if !@port.empty? and @port[0].is_a? Array and @port[0][0].is_a? Hash
-        @dot[@name] = @port[0][0]
-      end
-    end
-
-    # This generates a directed edge from this node to given node.
-    def >>(node)
-      @dot.directed!
-      add_edge_on_dot node
-    end
-
-    # This generates a undirected edge from this node to given node.
-    def -(node)
-      @dot.undirected!
-      add_edge_on_dot node
-    end
-
-    def add_edge_on_dot(node)
-      attr = nil
-      if node.is_a? Array
-        node = NodeGroup.new node
-        attr = @attr
-      else
-        attr = @attr.merge node.attr
-      end
-      edge = Edge.new([self, node], @dot, attr)
-      @dot.add_edge edge
-      edge
-    end
-
-    def [](attr)
-      @dot[@name] = attr
-      @attr.merge! attr
-      self
-    end
-
-    def <=>(other)
-      @name <=> other.name
-    end
-
-    def to_sym
-      self
-    end
-
-    def to_dot
-      name = @port.dup
-      name.unshift @name
-      name.map{|e| e.to_dot}.join(':')
-    end
-  end
-  
-  # Aggregate some nodes.
-  class NodeGroup
-    def initialize(nodes, attr={})
-      @nodes = nodes
-      @attributes = attr
-    end
-
-    def to_sym
-      to_dot.to_sym
-    end
-
-    def to_dot
-      dot = "{"
-      dot += @attributes.to_a.map{|e| "#{e[0]} = #{e[1]};"}.join(' ') unless @attributes.empty?
-      dot += ' ' unless @attributes.empty?
-      dot += @nodes.map{|e| "#{e.to_dot};"}.join(' ')
-      dot += "}"
-    end
-  end
-
-  # This represents a graphviz edge.
-  class Edge
-    def initialize(nodes, dot, attr={})
-      @nodes = nodes
-      @dot = dot
-      @attribute = attr
-    end
-
-    def [](attr)
-      @attribute.merge! attr
-    end
-
-    def >>(node, attr={})
-      @nodes << node
-      self[attr]
-      self
-    end
-
-    def node_to_dot(node)
-      node.is_a?(Array) ? node.map{|e| e.to_sym.to_dot}.join(':') : node.to_sym.to_dot
-    end
-
-    def to_dot
-      dot = @nodes.map{|e| node_to_dot e}.join " #{@dot.arrow} "
-      dot += " #{@attribute.to_dot}" unless @attribute.empty?
-      dot
-    end
-
-    def <=>(other)
-      to_dot <=> other.to_dot
-    end
-  end
-
-  # This returns dot formatted string from given attributes. To know more about <tt>attr</tt>,
-  # please see GraphvizR.new .
-  def self.dot(name, attr)
-    GraphvizR.new(name, attr).to_dot
-  end
+  attr_reader :statements, :graph_type
 
   # This initialzes a GraphvizR instance.
   # +name+:: the name of the graph
-  # +attr+:: <b>!deprecated!</b> all attributes for a graph can be given as a hash instance.
-  #          Please guess the contents of the hash from the test or examples below:
-  #            gvr = GraphvizR.dot(:sample, 
-  #              :graph => {:size => "1.5, 2.5"},
-  #              :label => 'example',
-  #              :node_attributes => {
-  #                :beta => {:shape => :box},
-  #              },
-  #              :alpha => :beta,
-  #              {:alpha => :gamma} => {:label => 'label1'},
-  #              :beta => :delta,
-  #              :delta => 'size'
-  #            )
-  #
-  #      gvr = GraphvizR.dot(:sample, 
-  #              :graph => {:size => "1.5, 2.5"},
-  #              :node => {:shape => :record},
-  #              :node_attributes => {
-  #                :node1 => {:label => "<p_left> left|<p_center>center|<p_right> right"},
-  #                :node2 => {:label => "left|center|right"}
-  #              },
-  #              :node1 => :node2,
-  #              [:node1, :p_left] => :node2,
-  #              :node2 => [:node1, :p_center],
-  #              {:node2 => [:node1, :p_right]} => {:label => 'record'}
-  #            )
-  #
-  #      gvr = GraphvizR.dot(:sample, 
-  #              :subgraphs => {
-  #                :cluster0 => {
-  #                  :color => :blue,
-  #                  :style => :bold,
-  #                  :label => "area 0",
-  #                  {:a => :b} => {},
-  #                  :a => :c
-  #                },
-  #                :cluster1 => {
-  #                  :fillcolor => "#cc9966",
-  #                  :style => :filled,
-  #                  :label => "area 1",
-  #                  [:d] => :e,
-  #                  :d => :f
-  #                }
-  #              },
-  #              :b => :d,
-  #              {:c => :d} => {:ltail => :cluster0},
-  #              {:c => :f} => {:lhead => :cluster1},
-  #              {:a => :f} => {:ltail => :cluster0, :lhead => :cluster1}
-  #            )
   # +parent+:: a parent graph is given when this graph is a subgraph.
   # +indent+:: indent level when this instance is converted to rdot.
-  def initialize(name, attr={}, parent=nil, indent=0)
-    if name.is_a? Array
-      initialize(*name)
-    else
-      @name = name
-      @default_graph_attributes = {}
-      @default_node_attributes = {}
-      @default_edge_attributes = {}
-      @node_attributes = {}
-      @edges = []
-      @subgraphs = []
-      @node_groups = []
-      @indent = indent + 1
-      @parent = parent
-      @directed = true
-      interprete attr
-    end
-  end
-
-  def interprete(attr) #:nodoc:
-    attr.each do |k, v|
-      case k
-      when :node_attribute, :node_attributes
-        add_node_attributes v
-      when :graph
-        @default_graph_attributes.merge! v
-      when :label, :size, :color, :fillcolor, :style
-        @default_graph_attributes[k] = v
-      when :node
-        @default_node_attributes[k] = v
-      when :edge
-        @default_edge_attributes[k] = v
-      when :subgraphs
-        add_subgraph(v)
-      else
-        add_edge k, v
-      end
-    end
-  end
-
-  # add attributes for nodes
-  def add_node_attributes(attrs)
-    @node_attributes = attrs
-  end
-
-  # add an edge to the graph
-  def add_edge(from, to=nil)
-    if from.is_a? Hash
-      f = from.keys[0]
-      t = from[f]
-      p = to
-      @edges << Edge.new([f, t], self, p)
-    elsif to.nil? 
-      # from is Edge instance
-      @edges << from 
-    else
-      @edges << Edge.new([from, to], self)
-    end
-  end
-
-  # add subgraph
-  def add_subgraph(graphs)
-    graphs.to_a.sort.each do |key_attr|
-      @subgraphs << self.class.new(key_attr[0], key_attr[1], self, @indent)
-    end
-  end
-  
-  # is this graph subgraph or not.
-  def subgraph?
-    not @parent.nil?
-  end
-
-  # make this graph directed
-  def directed!
-    if subgraph?
-      @parent.directed!
-    else
-      @directed = true
-    end
-  end
-
-  # make this graph undirected
-  def undirected!
-    if subgraph?
-      @parent.undirected!
-    else
-      @directed = false
-    end
-  end
-
-  # is this graph directed?
-  def directed?
-    if subgraph?
-      @parent.directed?
-    else
-      @directed
-    end
-  end
-
-  # is this graph undirected?
-  def undirected?
-    if subgraph?
-      @parent.undirected?
-    else
-      !@directed
-    end
-  end
-
-  def arrow
-    directed? ? '->' : '--'
-  end
-
-  # When block is given, create new subgraph. Otherwise, create new node.
-  def [](key, *args, &block)
+  def initialize(name, parent=nil, indent=0)
+    @name = name
+    @parent = parent
+    @graph_type = 'digraph'
+    @indent = indent
+    @directed = true
+    @statements = []
+  end
+
+  # if block is not given, this generates a node.
+  # if block given, generates a subgraph.
+  def [](name, *args, &block)
     if block
-      subgraph = self.class.new key, {}, self, @indent
+      subgraph = self.class.new name, self, @indent + 1
       block.call subgraph
-      @subgraphs << subgraph
+      @statements << subgraph
     else
-      Node.new key, args, self
+      node = Node.new name, args, self
+      @statements << node
+      node
     end
   end
 
-  # set attributes for a node
-  def []=(key, *args, &block)
-    @node_attributes[key] = args[0]
-  end
-
-  [:label, :size, :color, :fillcolor, :style].each do |method|
-    define_method :"#{method}=" do |v|
-      @default_graph_attributes[method] = v
+  ['digraph', 'graph', 'subgraph'].each do |graph_type|
+    define_method :"to_#{graph_type}" do
+      @graph_type = graph_type
     end
   end
 
-  # set graph attributes
-  def graph(*args)
-    if args.empty?
-      Attributes.new :graph, self
-    else
-      self.graph = args[0][0]
+  # set all nodes as same level
+  def rank(same, nodes=[])
+    group = NodeGroup.new nodes, :rank => same
+    nodes.size.times do
+      @statements.pop
     end
-  end
-
-  # set graph attributes
-  def graph=(attr)
-    @default_graph_attributes.merge! attr
-  end
-
-  def rank(same, nodes) 
-    @node_groups << (NodeGroup.new nodes, {:rank => same})
-  end
-
-  # convert this instance to dot
-  def to_dot
-    graph_type = if subgraph?; 'subgraph'elsif directed?; 'digraph' else 'graph' end
-    dot = indent_enter("#{graph_type} #{@name} {", true)
-    dot += indent_enter("graph #{@default_graph_attributes.to_dot};") unless @default_graph_attributes.empty?
-    dot += @subgraphs.map{|e| e.to_dot}.join('') unless @subgraphs.empty?
-    dot += attributes_to_dot(@default_node_attributes) unless @default_node_attributes.empty?
-    dot += attributes_to_dot(@default_edge_attributes) unless @default_edge_attributes.empty?
-    dot += attributes_to_dot(@node_attributes) unless @node_attributes.empty?
-    dot += @edges.sort.map{|e| indent_enter("#{e.to_dot};")}.join("")
-    dot += @node_groups.map{|e| indent_enter("#{e.to_dot};")}.join("")
-    dot += indent_enter("}", true)
-    dot
-  end
-
-  def indent_enter(str, is_first=false) #:nodoc:
-    "#{INDENT_UNIT * (@indent - (is_first ? 1 : 0))}#{str}\n"
+    @statements << group
+    group
   end
 
   # If <tt>format</tt> is 'dot', a dot string is generated. Otherwise, this generates image file
@@ -527,25 +216,152 @@ class GraphvizR
     end
   end
 
+  # convert this instance to dot
+  def to_dot(indent=@indent)
+    to_subgraph if @parent
+    dot = INDENT_UNIT * indent
+    dot += "#{@graph_type} #{@name} {\n"
+    @statements.each do |statement|
+      dot += statement.to_dot(indent + 1)
+    end
+    dot += INDENT_UNIT * indent
+    dot += "}\n"
+    dot
+  end
+
+  # redirect to [] method.
   def method_missing(name, *args, &block) #:nodoc:
-    method = 
-    if name.to_s =~ /=$/
-      name = name.to_s[0..-2].to_sym
-      :"[]="
-    else
-      :"[]"
+    self.send(:"[]", name, *args, &block)
+  end
+
+  # This represents graphviz node.
+  class Node
+    attr_reader :name, :parent
+    
+    def initialize(name, args, parent)
+      @parent = parent
+      @name = name
+      @edge = nil
+      @port = nil
+      @attributes = {}
+      unless args.empty?
+        arg = args[0]
+        if arg.is_a? Symbol
+          @port = arg
+          @attributes = {}
+        elsif arg.is_a? Array
+          @port = nil
+          @attributes = arg[0]
+        end
+      end
+    end
+
+    # if blank between node and attributes does not exist, this method is used.
+    # otherwise GraphvizR#[] is used.
+    # ex) gvr.graph[:label => 'example', :size => '1.5, 2.5']
+    def [](attributes)
+      @attributes = attributes
+    end
+
+    # generate an edge from self to given node.
+    # this generates a directed edge.
+    def >>(node)
+      @parent.to_digraph
+      @edge = Edge.new self, node, @parent
+    end
+
+    # generate an edge from self to given node.
+    # this generates a undirected edge.
+    def -(node)
+      @parent.to_graph
+      @edge = Edge.new self, node, @parent, '--'
+    end
+
+    # to string
+    def to_s
+      if @port
+        "#{@name}:#{@port}"
+      else
+        @name
+      end
+    end
+
+    # to dot format
+    def to_dot(indent=0)
+      attributes = @attributes.empty? ? '' : ' ' + @attributes.to_dot
+      "#{INDENT_UNIT * indent}#{@name}#{attributes};\n"
+    end
+  end
+
+  # This represents a graphviz edge.
+  class Edge
+    def initialize(from, to, parent, arrow='->')
+      @attributes = {}
+      @nodes = [from, to]
+      @arrow = arrow
+      @parent = parent
+      (from.is_a?(Array) ? from : [from]).size.times do
+        @parent.statements.pop
+      end
+      (to.is_a?(Array) ? to : [to]).size.times do
+        @parent.statements.pop
+      end
+      @parent.statements << self
+    end
+
+    # set attributes for the edge
+    def [](attributes)
+      @attributes = attributes
+    end
+
+    # consequent directed edge
+    def >>(node)
+      @parent.to_digraph
+      (node.is_a?(Array) ? node : [node]).size.times do
+        @parent.statements.pop
+      end
+      @nodes << node
+      self
+    end
+
+    # consequent undirected edge
+    def -(node)
+      @parent.to_graph
+      (node.is_a?(Array) ? node : [node]).size.times do
+        @parent.statements.pop
+      end
+      @nodes << node
+      self
+    end
+
+    # to dot
+    def to_dot(indent)
+      edge = @nodes.map{|e| e.is_a?(Array) ? e.to_dot : e.to_s}.join(" #{@arrow} ")
+      attributes = @attributes.empty? ? '' : ' ' + @attributes.to_dot
+      "#{INDENT_UNIT * indent}#{edge}#{attributes};\n"
     end
-    self.send(method, name, *args, &block)
   end
 
-protected
+  # this represent a group of nodes
+  class NodeGroup
+    def initialize(nodes, opts)
+      @nodes = nodes
+      @opts = opts
+    end
 
-  def attributes_to_dot(hash) #:nodoc:
-    hash.to_a.sort.map{|e| indent_enter "#{e[0]} #{e[1].to_dot};"}.join()
+    def to_dot(indent)
+      options = @opts.to_a.map{|e| "#{e[0]} = #{e[1]};"}.join ' '
+      nodes = @nodes.map{|e| "#{e.to_s};"}.join ' '
+      "#{INDENT_UNIT * indent}{#{options} #{nodes}};\n"
+    end
   end
 end
 
-class Numeric #:nodoc:
+class Symbol #:nodoc:
+  def <=>(other)
+    to_s <=> other.to_s
+  end
+
   def to_dot
     to_s
   end
@@ -557,18 +373,23 @@ class String #:nodoc:
   end
 end
 
-class Symbol #:nodoc:
+class Hash #:nodoc:
   def to_dot
-    to_s
+    "[#{to_a.sort.map{|e| "#{e[0].to_dot} = #{e[1].to_dot}"}.join(', ')}]"
   end
+end
 
-  def <=>(other)
-    to_s <=> other.to_s
+class Array #:nodoc:
+  def >>(node)
+    raise NoMethodError if empty? or not node.is_a? GraphvizR::Node
+    
+    parent = self[0].parent
+    parent.to_digraph
+    GraphvizR::Edge.new self, node, parent
   end
-end
 
-class Hash #:nodoc:
   def to_dot
-    "[#{to_a.sort.map{|e| "#{e[0].to_dot} = #{e[1].to_dot}"}.join(', ')}]"
+    "{#{self.map{|e| e.to_s}.join('; ')};}"
   end
 end
+

data/test/test_graphviz_r.rb

@@ -1,181 +1,156 @@
-# ref. http://homepage3.nifty.com/kaku-chan/graphviz/index.html
-
 require 'test/unit'
 require 'graphviz_r'
 
 class TestGraphvizR < Test::Unit::TestCase
-  def test_string_to_dot
-    assert_equal '"str"', "str".to_dot
+  def test_access_as_hash
+    gvr = GraphvizR.new 'sample'
+    (gvr['alpha'] >> gvr['beta']) [:label => "label1"]
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  alpha -> beta [label = "label1"];
+}
+    end_of_string
+  end
+
+  def test_no_node
+    gvr = GraphvizR.new 'sample'
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+}
+    end_of_string
   end
 
-  def test_symbol_to_dot
-    assert_equal "sym", :sym.to_dot
+  def test_just_node
+    gvr = GraphvizR.new 'sample'
+    gvr.alpha
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  alpha;
+}
+    end_of_string
   end
 
-  def test_hash_to_dot
-    assert_equal '[k1 = v1, k2 = "v2"]', {:k1 => :v1, :k2 => "v2"}.to_dot
+  def test_graph_setting
+    gvr = GraphvizR.new 'sample'
+    gvr.graph [:label => 'example', :size => '1.5, 2.5']
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  graph [label = "example", size = "1.5, 2.5"];
+}
+    end_of_string
   end
 
-  def test_basic
-    gvr = GraphvizR.dot(:sample, 
-                        :graph => {:size => "1.5, 2.5"},
-                        :label => 'example',
-                        :node_attributes => {
-                          :beta => {:shape => :box},
-                        },
-                        :alpha => :beta,
-                        {:alpha => :gamma} => {:label => 'label1'},
-                        :beta => :delta,
-                        :delta => 'size'
-                        )
-
-    assert_equal <<-end_of_string, gvr
+  def test_graph_setting_without_blank
+    gvr = GraphvizR.new 'sample'
+    gvr.graph[:label => 'example', :size => '1.5, 2.5']
+
+    assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
   graph [label = "example", size = "1.5, 2.5"];
-  beta [shape = box];
-  alpha -> beta;
-  alpha -> gamma [label = "label1"];
-  beta -> delta;
-  delta -> size;
 }
     end_of_string
   end
 
-  #gvr.graph = {:label => 'example', :size => '1.5, 2.5'}
-  #gvr.beta = {:shape => :box}
-  #gvr.graph[:label => 'example', :size => '1.5, 2.5']
-  #gvr.beta[:shape => :box]
-  def test_basic_dynamic
+  def test_edge
     gvr = GraphvizR.new 'sample'
-    gvr.graph [:label => 'example', :size => '1.5, 2.5'] 
-    gvr.beta [:shape => :box]                            
     gvr.alpha >> gvr.beta
-    (gvr.alpha >> gvr.gamma) [:label => 'label1']
-    (gvr.beta >> gvr.delta) [:label => 'label2']
-    gvr.delta >> gvr[:size]
 
     assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  graph [label = "example", size = "1.5, 2.5"];
-  beta [shape = box];
   alpha -> beta;
-  alpha -> gamma [label = "label1"];
-  beta -> delta [label = "label2"];
-  delta -> size;
 }
     end_of_string
   end
 
-  def test_record
-    gvr = GraphvizR.dot(:sample, 
-                        :graph => {:size => "1.5, 2.5"},
-                        :node => {:shape => :record},
-                        :edge => {:fontsize => 24},
-                        :node_attributes => {
-                          :node1 => {:label => "<p_left> left|<p_center>center|<p_right> right"},
-                          :node2 => {:label => "left|center|right"}
-                        },
-                        :node1 => :node2,
-                        [:node1, :p_left] => :node2,
-                        :node2 => [:node1, :p_center],
-                        {:node2 => [:node1, :p_right]} => {:label => 'record'}
-                        )
-
-    assert_equal <<-end_of_string, gvr
+  def test_edge_with_attributes
+    gvr = GraphvizR.new 'sample'
+    (gvr.alpha >> gvr.beta) [:label => 'label1']
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  alpha -> beta [label = "label1"];
+}
+    end_of_string
+  end
+
+  def test_edge_with_attributes_without_blank
+    gvr = GraphvizR.new 'sample'
+    (gvr.alpha >> gvr.beta)[:label => 'label1']
+
+    assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  graph [size = "1.5, 2.5"];
-  node [shape = record];
-  edge [fontsize = 24];
-  node1 [label = "<p_left> left|<p_center>center|<p_right> right"];
-  node2 [label = "left|center|right"];
-  node1 -> node2;
-  node1:p_left -> node2;
-  node2 -> node1:p_center;
-  node2 -> node1:p_right [label = "record"];
+  alpha -> beta [label = "label1"];
 }
     end_of_string
   end
 
-  #gvr.size = '1.5, 2.5'
-  #gvr.node = {:shape => :record}
-  #d gvr.node1 = {:label => "<p_left> left|<p_center>center|<p_right> right"}
-  #gvr.node2 = {:label => "left|center|right"}
-  def test_record_dynamic
+  def test_record_edge
     gvr = GraphvizR.new 'sample'
-    gvr.graph [:size => '1.5, 2.5']
-    gvr.node [:shape => :record]
-    gvr.node1 [:label => "<p_left> left|<p_center>center|<p_right> right"]
-    gvr.node2 [:label => "left|center|right"]
-    gvr.node1 >> gvr.node2
     gvr.node1(:p_left) >> gvr.node2
     gvr.node2 >> gvr.node1(:p_center)
-    (gvr.node2 >> gvr.node1(:p_right)) [:label => 'record']
 
     assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  graph [size = "1.5, 2.5"];
-  node [shape = record];
-  node1 [label = "<p_left> left|<p_center>center|<p_right> right"];
-  node2 [label = "left|center|right"];
-  node1 -> node2;
   node1:p_left -> node2;
   node2 -> node1:p_center;
+}
+    end_of_string
+  end
+
+  def test_record_edge_with_attributes
+    gvr = GraphvizR.new 'sample'
+    (gvr.node2 >> gvr.node1(:p_right)) [:label => 'record']
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
   node2 -> node1:p_right [label = "record"];
 }
     end_of_string
   end
 
-  def test_subgraph
-    gvr = GraphvizR.dot(:sample, 
-                        :subgraphs => {
-                          :cluster0 => {
-                            :color => :blue,
-                            :style => :bold,
-                            :label => "area 0",
-                            {:a => :b} => {},
-                            :a => :c
-                          },
-                          :cluster1 => {
-                            :fillcolor => "#cc9966",
-                            :style => :filled,
-                            :label => "area 1",
-                            [:d] => :e,
-                            :d => :f
-                          }
-                        },
-                        :b => :d,
-                        {:c => :d} => {:ltail => :cluster0},
-                        {:c => :f} => {:lhead => :cluster1},
-                        {:a => :f} => {:ltail => :cluster0, :lhead => :cluster1}
-                        )
-
-    assert_equal <<-end_of_string, gvr
+  def test_simple_graph
+    gvr = GraphvizR.new 'sample'
+    gvr.graph [:label => 'example', :size => '1.5, 2.5'] 
+    gvr.beta [:shape => :box]                            
+    gvr.alpha >> gvr.beta
+    (gvr.alpha >> gvr.gamma) [:label => 'label1']
+    (gvr.beta >> gvr.delta) [:label => 'label2']
+    gvr.delta >> gvr[:size]
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  graph [label = "example", size = "1.5, 2.5"];
+  beta [shape = box];
+  alpha -> beta;
+  alpha -> gamma [label = "label1"];
+  beta -> delta [label = "label2"];
+  delta -> size;
+}
+    end_of_string
+  end
+
+  def test_define_subgraph
+    gvr = GraphvizR.new 'sample'
+    gvr.cluster0 do |c0|
+      c0.graph [:color => :blue, :label => 'area 0', :style => :bold]
+      c0.a >> c0.b
+    end
+    
+    assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
   subgraph cluster0 {
     graph [color = blue, label = "area 0", style = bold];
     a -> b;
-    a -> c;
-  }
-  subgraph cluster1 {
-    graph [fillcolor = "#cc9966", label = "area 1", style = filled];
-    d -> e;
-    d -> f;
   }
-  a -> f [lhead = cluster1, ltail = cluster0];
-  b -> d;
-  c -> d [ltail = cluster0];
-  c -> f [lhead = cluster1];
 }
     end_of_string
   end
 
-  #c0.color = :blue
-  #c0.label = 'area 0'
-  #c0.style = :bold
-  #c1.fillcolor = '#cc9966'
-  #c1.label = 'area 1'
-  #c1.style = :filled
-  def test_subgrpah_dynamic
+  def test_subgraph
     gvr = GraphvizR.new 'sample'
     gvr.cluster0 do |c0|
       c0.graph [:color => :blue, :label => 'area 0', :style => :bold]
@@ -214,26 +189,18 @@ digraph sample {
 
   def test_undirected_graph
     gvr = GraphvizR.new 'sample'
-    gvr.graph [:label => 'example', :size => '1.5, 2.5'] 
-    gvr.beta [:shape => :box]                            
     gvr.alpha - gvr.beta
-    (gvr.alpha - gvr.gamma) [:label => 'label1']
-    (gvr.beta - gvr.delta) [:label => 'label2']
-    gvr.delta - gvr[:size]
+    (gvr.beta - gvr.gamma) [:label => 'label2']
 
     assert_equal <<-end_of_string, gvr.to_dot
 graph sample {
-  graph [label = "example", size = "1.5, 2.5"];
-  beta [shape = box];
   alpha -- beta;
-  alpha -- gamma [label = "label1"];
-  beta -- delta [label = "label2"];
-  delta -- size;
+  beta -- gamma [label = "label2"];
 }
     end_of_string
   end
 
-  def test_undirected_subgrpah
+  def test_undirected_subgraph
     gvr = GraphvizR.new 'sample'
     gvr.cluster0 do |c0|
       c0.graph [:color => :blue, :label => 'area 0', :style => :bold]
@@ -270,98 +237,133 @@ graph sample {
     end_of_string
   end
 
-  def test_data
+  def test_consective_edges
     gvr = GraphvizR.new 'sample'
-    gvr.graph [:label => 'example', :size => '1.5, 2.5'] 
-    gvr.beta [:shape => :box]                            
     gvr.alpha >> gvr.beta
-    (gvr.alpha >> gvr.gamma) [:label => 'label1']
-    (gvr.beta >> gvr.delta) [:label => 'label2']
-    gvr.delta >> gvr[:size]
+    gvr.alpha >> gvr.beta >> gvr.gamma
+    gvr.alpha >> gvr.beta >> gvr.gamma >> gvr.delta
 
-    assert_equal <<-end_of_string, gvr.data(:dot)
+    assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  graph [label = "example", size = "1.5, 2.5"];
-  beta [shape = box];
   alpha -> beta;
-  alpha -> gamma [label = "label1"];
-  beta -> delta [label = "label2"];
-  delta -> size;
+  alpha -> beta -> gamma;
+  alpha -> beta -> gamma -> delta;
 }
     end_of_string
   end
 
-  def test_access_as_hash
+  def test_consective_undirected_edges
     gvr = GraphvizR.new 'sample'
-    (gvr['alpha'] >> gvr['beta']) [:label => "label1"]
+    gvr.alpha - gvr.beta
+    gvr.alpha - gvr.beta - gvr.gamma
+    gvr.alpha - gvr.beta - gvr.gamma - gvr.delta
 
-    assert_equal <<-end_of_string, gvr.data(:dot)
+    assert_equal <<-end_of_string, gvr.to_dot
+graph sample {
+  alpha -- beta;
+  alpha -- beta -- gamma;
+  alpha -- beta -- gamma -- delta;
+}
+    end_of_string
+  end
+
+  def test_node_grouping
+    gvr = GraphvizR.new 'sample'
+    gvr.alpha >> [gvr.beta, gvr.gamma, gvr.delta]
+
+    assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  "alpha" -> "beta" [label = "label1"];
+  alpha -> {beta; gamma; delta;};
 }
     end_of_string
   end
 
-  def test_consective_edges
+  def test_node_grouping_reverse
     gvr = GraphvizR.new 'sample'
-    gvr.alpha >> gvr.beta
-    gvr.alpha >> gvr.beta >> gvr.gamma
-    gvr.alpha >> gvr.beta >> gvr.gamma >> gvr.delta
+    [gvr.beta, gvr.gamma, gvr.delta] >> gvr.alpha
 
     assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  alpha -> beta;
-  alpha -> beta -> gamma;
-  alpha -> beta -> gamma -> delta;
+  {beta; gamma; delta;} -> alpha;
 }
     end_of_string
   end
 
-  def test_node_group
+  def test_consective_node_grouping
     gvr = GraphvizR.new 'sample'
-#    gvr.a >> gvr.grouping(){gvr.b, gvr.c, gvr.d}
-#    gvr.aa >> gvr.grouping(gvr.bb, gvr.cc, gvr.dd)
-#  a -> {b c d};
-#  aa -> {bb cc dd};
-    gvr.aaa >> [gvr.bbb, gvr.ccc, gvr.ddd]
+    gvr.alpha >> gvr.beta >> [gvr.gamma, gvr.delta]
 
     assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  aaa -> {bbb; ccc; ddd;};
+  alpha -> beta -> {gamma; delta;};
+}
+    end_of_string
+  end
+
+  def test_intermediate_defaults
+    gvr = GraphvizR.new 'example'
+    gvr.dummy1 [:label => 'dummy1']
+    gvr.graph [:size => "3, 3"]
+    gvr.dummy2 [:label => 'dummy2']
+    gvr.node [:shape => :box]
+    gvr.dummy3 [:label => 'dummy3']
+    gvr.edge [:fontcolor => :red]
+    gvr.dummy4 [:label => 'dummy4']
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph example {
+  dummy1 [label = "dummy1"];
+  graph [size = "3, 3"];
+  dummy2 [label = "dummy2"];
+  node [shape = box];
+  dummy3 [label = "dummy3"];
+  edge [fontcolor = red];
+  dummy4 [label = "dummy4"];
 }
     end_of_string
   end
 
   def test_rank
     gvr = GraphvizR.new 'sample'
-    gvr.graph [:size => "3, 3"]
-    gvr.Level_1 >> gvr.Level_2 >> gvr.Level_3
-    gvr.a >> gvr.b
-    gvr.a >> gvr.c
-    gvr.a >> gvr.d
-    gvr.b >> gvr.c
-    gvr.b >> gvr.e
-    gvr.d >> gvr.e
-    gvr.d >> gvr.f
-    #gvr.grouping(:rank => :same) {gvr.Level_1; gvr.a}
     gvr.rank :same, [gvr.Level_1, gvr.a]
-    gvr.rank :same, [gvr.Level_2, gvr.c, gvr.b, gvr.d]
-    gvr.rank :same, [gvr.Level_3, gvr.e, gvr.f]
 
     assert_equal <<-end_of_string, gvr.to_dot
 digraph sample {
-  graph [size = "3, 3"];
-  Level_1 -> Level_2 -> Level_3;
-  a -> b;
-  a -> c;
-  a -> d;
-  b -> c;
-  b -> e;
-  d -> e;
-  d -> f;
   {rank = same; Level_1; a;};
-  {rank = same; Level_2; c; b; d;};
-  {rank = same; Level_3; e; f;};
+}
+    end_of_string
+  end
+
+=begin
+  def test_rank_new
+    gvr = GraphvizR.new 'sample'
+    gvr.group {|gvr| gvr.rank = :same, gvr.Level_1, gvr.a}
+
+    assert_equal <<-end_of_string, gvr.to_dot
+digraph sample {
+  {rank = same; Level_1; a;};
+}
+    end_of_string
+  end
+=end
+
+  def test_data
+    gvr = GraphvizR.new 'sample'
+    gvr.graph [:label => 'example', :size => '1.5, 2.5'] 
+    gvr.beta [:shape => :box]                            
+    gvr.alpha >> gvr.beta
+    (gvr.alpha >> gvr.gamma) [:label => 'label1']
+    (gvr.beta >> gvr.delta) [:label => 'label2']
+    gvr.delta >> gvr[:size]
+
+    assert_equal <<-end_of_string, gvr.data(:dot)
+digraph sample {
+  graph [label = "example", size = "1.5, 2.5"];
+  beta [shape = box];
+  alpha -> beta;
+  alpha -> gamma [label = "label1"];
+  beta -> delta [label = "label2"];
+  delta -> size;
 }
     end_of_string
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: GraphvizR
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2007-02-26 00:00:00 +09:00
+  version: 0.5.0
+date: 2007-03-11 00:00:00 +09:00
 summary: Graphviz wrapper for Ruby and Rails
 require_paths: 
   - lib