gviz 0.0.5 → 0.0.6

data/README.md

@@ -105,6 +105,28 @@ This outputs below.
 
 Another examples are at `examples` directory
 
+## gviz command
+It comes with a `gviz` command. This works with a graph spec file. If 'graph.ru' file exist on a directory of the execution, it will be automatically loaded as a graph spec file.
+
+Example of graph.ru:
+
+      route :main => [:init, :parse, :cleanup, :printf]
+      route :init => :make, :parse => :execute
+      route :execute => [:make, :compare, :printf]
+
+      save(:sample, :png)
+
+Usage:
+
+      gviz [options] <graph filename>
+
+where [options] are:
+
+    --name,   -n :   Graph name (default: G)
+    --type,   -t :   Graph type (default: digraph)
+    --version, -v:   Print version and exit
+    --help,    -h:   Show this message
+
 ## Contributing
 
 1. Fork it

data/bin/gviz

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require "gviz"
+require "trollop"
+
+def gfile_eval(gfile, opts)
+  Graph(opts[:name], opts[:type]) { instance_eval ::File.read(gfile) }
+rescue Errno::ENOENT
+  abort "graph file `#{gfile}` not found"
+end
+
+opts = Trollop::options do
+  version "Gviz #{Gviz::VERSION} (c) 2012 kyoendo"
+  banner <<-EOS
+Gviz is a tool for generating graphviz dot data with simple Ruby's syntax. It works with a graph spec file in which a graph spec describes with several gviz commands. If 'graph.ru' file exist on a directory of the execution, it will be automatically loaded as a graph spec file.
+
+Example of graph.ru:
+
+      route :main => [:init, :parse, :cleanup, :printf]
+      route :init => :make, :parse => :execute
+      route :execute => [:make, :compare, :printf]
+
+      save(:sample, :png)
+
+Usage:
+
+      gviz [options] <graph filename>
+
+where [options] are:
+EOS
+
+  opt :name, "Graph name", :default => 'G'
+  opt :type, "Graph type", :default => 'digraph'
+end
+
+gfile = ARGV[0] || "graph.ru"
+gfile_eval(gfile, opts)

data/gviz.gemspec

@@ -16,4 +16,7 @@ Gem::Specification.new do |gem|
   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"]
+  gem.required_ruby_version = '>=1.9.3'
+  gem.add_development_dependency 'rspec'
+  gem.add_dependency 'thor'
 end

data/lib/gviz.rb

@@ -1,218 +1,11 @@
-require_relative "gviz/system_extension"
-
+# encoding: UTF-8
 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)
-      raise ArgumentError, "id must not include other than words or a colon" if id.match(/[^\w:]/)
-      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
 
 def Graph(name=:G, type=:digraph, &blk)
   Gviz.new(name, type).graph(&blk)
 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
+%w(core node edge version system_extension).each do |lib|
+  require_relative 'gviz/' + lib
 end
-

data/lib/gviz/core.rb

@@ -0,0 +1,154 @@
+class Gviz
+  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

data/lib/gviz/edge.rb

@@ -0,0 +1,29 @@
+class Gviz::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)
+    raise ArgumentError, "id must not include other than words or a colon" if id.match(/[^\w:]/)
+    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
+

data/lib/gviz/node.rb

@@ -0,0 +1,11 @@
+class Gviz::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
+

data/lib/gviz/version.rb

@@ -1,3 +1,3 @@
-module Gviz
-  VERSION = "0.0.5"
+class Gviz
+  VERSION = "0.0.6"
 end

data/spec/graph.ru

@@ -0,0 +1,2 @@
+route :a => :b
+puts self

data/spec/gviz_command_spec.rb

@@ -0,0 +1,49 @@
+require_relative "spec_helper"
+
+ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+
+describe "gviz command" do
+  context "when a graph file exist" do
+    subject { syscmd "#{ROOT}/bin/gviz spec/graph.ru" }
+    it do
+      should eql ~<<-EOS
+        digraph G {
+          a;
+          b;
+          a -> b;
+        }
+        EOS
+    end
+  end
+
+  context "when a graph file not exist" do
+    subject { syscmd "#{ROOT}/bin/gviz", :err }
+    it { should eql "graph file `graph.ru` not found\n" }
+  end
+
+  context "when a name option passed" do
+    subject { syscmd "#{ROOT}/bin/gviz -n ABC spec/graph.ru" }
+    it do
+      should eql ~<<-EOS
+        digraph ABC {
+          a;
+          b;
+          a -> b;
+        }
+        EOS
+    end
+  end
+
+  context "when a type option passed" do
+    subject { syscmd "#{ROOT}/bin/gviz -t graph spec/graph.ru" }
+    it do
+      should eql ~<<-EOS
+        graph G {
+          a;
+          b;
+          a -> b;
+        }
+        EOS
+    end
+  end
+end

data/spec/gviz_edge_spec.rb

@@ -0,0 +1,67 @@
+# encoding: UTF-8
+require_relative "spec_helper"
+
+describe Gviz::Edge do
+  describe ".new" do
+    context "when a symbol with an underscore passed" do
+      subject { Gviz::Edge.new(:a_b) }
+      it { should be_a_instance_of Gviz::Edge }
+      its(:id) { should be :a_b }
+      its(:st) { should be :a }
+      its(:ed) { should be :b }
+      its(:seq) { should eq 0 }
+      its(:st_port) { should be_nil }
+      its(:ed_port) { should be_nil }
+      its(:to_s) { should eq "a -> b" }
+    end
+
+    context "when a string with an underscore passed" do
+      subject { Gviz::Edge.new('a_b') }
+      it { should be_a_instance_of Gviz::Edge }
+      its(:id) { should be :a_b }
+      its(:st) { should be :a }
+      its(:ed) { should be :b }
+      its(:seq) { should eq 0 }
+      its(:st_port) { should be_nil }
+      its(:ed_port) { should be_nil }
+      its(:to_s) { should eq "a -> b" }
+    end
+
+    context "when a symbol with two underscores passed" do
+      subject { Gviz::Edge.new('a_b_1') }
+      it { should be_a_instance_of Gviz::Edge }
+      its(:id) { should be :a_b_1 }
+      its(:st) { should be :a }
+      its(:ed) { should be :b }
+      its(:seq) { should eq 1 }
+      its(:st_port) { should be_nil }
+      its(:ed_port) { should be_nil }
+      its(:to_s) { should eq "a -> b" }
+    end
+
+    context "when a string with a colon passed" do
+      subject { Gviz::Edge.new('a:x_b:y') }
+      it { should be_a_instance_of Gviz::Edge }
+      its(:id) { should be :a_b }
+      its(:st) { should be :a }
+      its(:ed) { should be :b }
+      its(:seq) { should eq 0 }
+      its(:st_port) { should be :x }
+      its(:ed_port) { should be :y }
+      its(:to_s) { should eq "a:x -> b:y" }
+    end
+
+    context "when a symbol and hash options passed" do
+      opts = { style:'bold', color:'red' }
+      subject { Gviz::Edge.new(:a_b, opts) }
+      its(:id) { should be :a_b }
+      its(:attrs) { should eq opts }
+    end
+
+    context "when a string with other than words or colon passed" do
+      it "raise an error" do
+        ->{ Gviz::Edge.new('a!b_c') }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/gviz_node_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+require_relative "spec_helper"
+
+describe Gviz::Node do
+  describe ".new" do
+    context "when only a symbol passed" do
+      subject { Gviz::Node.new(:a) }
+      it { should be_a_instance_of Gviz::Node }
+      its(:id) { should be :a }
+      its(:attrs) { should be_empty }
+    end
+    
+    context "when only a string passed" do
+      subject { Gviz::Node.new('a') }
+      it { should be_a_instance_of Gviz::Node }
+      its(:id) { should eq 'a' }
+      its(:attrs) { should be_empty }
+    end
+
+    context "when a symbol and hash options passed" do
+      opts = { shape:'circle', style:'filled' }
+      subject { Gviz::Node.new(:a, opts) }
+      its(:id) { should be :a }
+      its(:attrs) { should eq opts }
+    end
+
+    context "when a symbol with underscore passed" do
+      it "raise an error" do
+        ->{ Gviz::Node.new(:a_b) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#to_s" do
+    subject { Gviz::Node.new(:a, style:'filled').to_s }
+    it { should eq "a" }
+  end
+end

data/spec/gviz_spec.rb

@@ -1,106 +1,5 @@
 # encoding: UTF-8
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe Gviz::Node do
-  describe ".new" do
-    context "when only a symbol passed" do
-      subject { Gviz::Node.new(:a) }
-      it { should be_a_instance_of Gviz::Node }
-      its(:id) { should be :a }
-      its(:attrs) { should be_empty }
-    end
-    
-    context "when only a string passed" do
-      subject { Gviz::Node.new('a') }
-      it { should be_a_instance_of Gviz::Node }
-      its(:id) { should eq 'a' }
-      its(:attrs) { should be_empty }
-    end
-
-    context "when a symbol and hash options passed" do
-      opts = { shape:'circle', style:'filled' }
-      subject { Gviz::Node.new(:a, opts) }
-      its(:id) { should be :a }
-      its(:attrs) { should eq opts }
-    end
-
-    context "when a symbol with underscore passed" do
-      it "raise an error" do
-        ->{ Gviz::Node.new(:a_b) }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#to_s" do
-    subject { Gviz::Node.new(:a, style:'filled').to_s }
-    it { should eq "a" }
-  end
-end
-
-describe Gviz::Edge do
-  describe ".new" do
-    context "when a symbol with an underscore passed" do
-      subject { Gviz::Edge.new(:a_b) }
-      it { should be_a_instance_of Gviz::Edge }
-      its(:id) { should be :a_b }
-      its(:st) { should be :a }
-      its(:ed) { should be :b }
-      its(:seq) { should eq 0 }
-      its(:st_port) { should be_nil }
-      its(:ed_port) { should be_nil }
-      its(:to_s) { should eq "a -> b" }
-    end
-
-    context "when a string with an underscore passed" do
-      subject { Gviz::Edge.new('a_b') }
-      it { should be_a_instance_of Gviz::Edge }
-      its(:id) { should be :a_b }
-      its(:st) { should be :a }
-      its(:ed) { should be :b }
-      its(:seq) { should eq 0 }
-      its(:st_port) { should be_nil }
-      its(:ed_port) { should be_nil }
-      its(:to_s) { should eq "a -> b" }
-    end
-
-    context "when a symbol with two underscores passed" do
-      subject { Gviz::Edge.new('a_b_1') }
-      it { should be_a_instance_of Gviz::Edge }
-      its(:id) { should be :a_b_1 }
-      its(:st) { should be :a }
-      its(:ed) { should be :b }
-      its(:seq) { should eq 1 }
-      its(:st_port) { should be_nil }
-      its(:ed_port) { should be_nil }
-      its(:to_s) { should eq "a -> b" }
-    end
-
-    context "when a string with a colon passed" do
-      subject { Gviz::Edge.new('a:x_b:y') }
-      it { should be_a_instance_of Gviz::Edge }
-      its(:id) { should be :a_b }
-      its(:st) { should be :a }
-      its(:ed) { should be :b }
-      its(:seq) { should eq 0 }
-      its(:st_port) { should be :x }
-      its(:ed_port) { should be :y }
-      its(:to_s) { should eq "a:x -> b:y" }
-    end
-
-    context "when a symbol and hash options passed" do
-      opts = { style:'bold', color:'red' }
-      subject { Gviz::Edge.new(:a_b, opts) }
-      its(:id) { should be :a_b }
-      its(:attrs) { should eq opts }
-    end
-
-    context "when a string with other than words or colon passed" do
-      it "raise an error" do
-        ->{ Gviz::Edge.new('a!b_c') }.should raise_error(ArgumentError)
-      end
-    end
-  end
-end
+require_relative "spec_helper"
 
 describe Gviz do
   let(:gv) { Gviz.new }

data/spec/spec_helper.rb

@@ -1,9 +1,16 @@
 require "gviz"
 require "rspec"
+require "stringio"
+require "open3"
 
 class String
   def ~
     margin = scan(/^ +/).map(&:size).min
     gsub(/^ {#{margin}}/, '')
   end
-end
+end
+
+def syscmd(cmd, io=:out)
+  idx = [:stdin, :stdout, :stderr].index { |st| st.match /#{io}/ }
+  Open3.popen3(cmd)[idx].read
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gviz
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,45 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
-dependencies: []
+date: 2012-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby's interface of graphviz
 email:
 - postagie@gmail.com
-executables: []
+executables:
+- gviz
 extensions: []
 extra_rdoc_files: []
 files:
@@ -23,6 +56,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/gviz
 - examples/arrows.rb
 - examples/colors.rb
 - examples/examples.rb
@@ -32,8 +66,15 @@ files:
 - examples/shapes.rb
 - gviz.gemspec
 - lib/gviz.rb
+- lib/gviz/core.rb
+- lib/gviz/edge.rb
+- lib/gviz/node.rb
 - lib/gviz/system_extension.rb
 - lib/gviz/version.rb
+- spec/graph.ru
+- spec/gviz_command_spec.rb
+- spec/gviz_edge_spec.rb
+- spec/gviz_node_spec.rb
 - spec/gviz_spec.rb
 - spec/spec_helper.rb
 - spec/system_extension_spec.rb
@@ -48,7 +89,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -62,6 +103,10 @@ signing_key:
 specification_version: 3
 summary: Ruby's interface of graphviz. It generate a dot file with simple ruby's syntax.
 test_files:
+- spec/graph.ru
+- spec/gviz_command_spec.rb
+- spec/gviz_edge_spec.rb
+- spec/gviz_node_spec.rb
 - spec/gviz_spec.rb
 - spec/spec_helper.rb
 - spec/system_extension_spec.rb