graph 1.2.0 → 2.0.0

data/lib/homebrew_analyzer.rb

@@ -0,0 +1,19 @@
+require 'dep_analyzer'
+
+class HomebrewAnalyzer < DepAnalyzer
+  def installed
+    # don't cache so it updates every delete
+    puts "scanning installed ports"
+    `brew list`.scan(/\S+/).map { |s| s.split.first }
+  end
+
+  def outdated
+    # don't cache so it updates every delete
+    puts "scanning outdated ports"
+    `brew outdated`.split(/\n/).map { |s| s.split.first }
+  end
+
+  def deps port
+    `brew deps #{port}`.scan(/\S+/)
+  end
+end

data/lib/rake_analyzer.rb

@@ -2,30 +2,27 @@ require 'dep_analyzer'
 
 class RakeAnalyzer < DepAnalyzer
   def run
-    require 'graph'
-    g = Graph.new
-    g.rotate
+    digraph do
+      rotate
+      boxes
 
-    current = nil
-    `rake -P -s`.each_line do |line|
-      case line
-      when /^rake (.+)/
-        name = $1
-        # current = (name =~ /pkg/) ? nil : name
-        current = name
-        g[current] if current # force the node to exist, in case of a leaf
-      when /^\s+(.+)/
-        dep = $1
-        next if current =~ /pkg/ and File.file? dep
-        g[current] << dep if current
-      else
-        warn "unparsed: #{line.chomp}"
+      current = nil
+      `rake -P -s`.each_line do |line|
+        case line
+        when /^rake (.+)/
+          name = $1
+          current = name
+          node current if current
+        when /^\s+(.+)/
+          dep = $1
+          next if current =~ /pkg/ and File.file? dep
+          edge current, dep if current
+        else
+          warn "unparsed: #{line.chomp}"
+        end
       end
-    end
-
 
-    g.boxes
-    g.save "#{self.class}"
-    system "open #{self.class}.png"
+      save "RakeAnalyzer", "png"
+    end
   end
 end

data/lib/rubygems_analyzer.rb

@@ -1,10 +1,15 @@
 require 'dep_analyzer'
 
+$a ||= false
+
 class RubygemsAnalyzer < DepAnalyzer
-  def installed
-    require 'rubygems'
+  def setup
+    require "rubygems"
     ENV['GEM_PATH'] = `gem env home`
     Gem.clear_paths
+  end
+
+  def installed
     # don't cache so it updates every delete
     puts "scanning installed rubygems"
     Gem.source_index.gems.values.map { |gem| gem.name }.sort
@@ -16,7 +21,23 @@ class RubygemsAnalyzer < DepAnalyzer
     Gem.source_index.outdated.sort
   end
 
-  def deps port
-    Gem.source_index.find_name(port).first.dependencies.map { |dep| dep.name }
+  def deps gem
+    Gem.source_index.find_name(gem).first.dependencies.map { |dep| dep.name }
+  end
+
+  def decorate
+    developer_dependency = g.gray
+
+    installed = self.installed
+
+    installed.each do |gem|
+      deps = Gem.source_index.find_name(gem).first.dependencies
+
+      deps.each do |dep|
+        next if dep.type == :runtime
+        name = dep.name
+        developer_dependency << g[gem][name] if $a or installed.include? name
+      end
+    end
   end
 end

data/test/test_graph.rb

@@ -2,123 +2,121 @@ require "minitest/autorun"
 require "tmpdir"
 require "graph"
 
+class String
+  def clean
+    gsub(/\s+(\[|\])/, ' \1')
+  end
+end
+
 class TestGraph < MiniTest::Unit::TestCase
+  attr_accessor :graph
+
+  def assert_attribute k, v, a
+    assert_kind_of Graph::Attribute, a
+    assert_equal "#{k} = #{v}", a.attr
+  end
+
+  def assert_graph graph, *lines
+    lines = lines.map { |l| "    #{l};" }.join("\n")
+    expected = "digraph \n  {\n#{lines}\n  }".sub(/\n\n/, "\n")
+    assert_equal expected, graph.to_s.clean
+  end
+
   def setup
     @graph = Graph.new
-    @graph["a"] << "b"
+    @graph["a"] >> "b"
   end
 
   def test_boxes
-    expected = util_dot('"a" -> "b"')
-    assert_equal expected, @graph.to_s
+    assert_graph graph, '"a" -> "b"'
 
-    @graph.boxes
+    graph.boxes
 
-    expected = util_dot('node [ shape = box ]',
-                        '"a" -> "b"')
-    assert_equal expected, @graph.to_s
+    assert_graph graph, 'node [ shape = box ]', '"a" -> "b"'
   end
 
-  def test_clear
-    @graph.clear
-
-    assert_empty @graph.prefix,  "prefix"
-    assert_empty @graph.order,   "order"
-    assert_empty @graph.attribs, "attribs"
-    assert_empty @graph.edge,    "edge"
+  def test_colorscheme
+    assert_attribute "colorscheme", "blah", graph.colorscheme("blah")
   end
 
-  def test_counts
-    expect = { "a" => 1, }
-    assert_equal expect, @graph.counts
-
-    @graph["a"] << "b"
-    @graph["a"] << "c"
-    @graph["b"] << "c"
+  def test_fillcolor
+    assert_attribute "fillcolor", "blah", graph.fillcolor("blah")
+  end
 
-    expect = { "a" => 3, "b" => 1, }
-    assert_equal expect, @graph.counts
+  def test_font
+    assert_attribute "fontname", '"blah"', graph.font("blah")
   end
 
-  def test_delete
-    assert_equal %w(b), @graph.delete("a")
-    assert_equal [], @graph.order
+  def test_font_size
+    # cheating... but I didn't want to write a more complex assertion
+    assert_attribute "fontname", '"blah", fontsize = 12', graph.font("blah", 12)
   end
 
-  def test_filter_size
-    @graph.filter_size 2
-    assert @graph.empty?
+  def test_digraph
+    g = digraph do
+      edge "a", "b", "c"
+    end
+
+    assert_kind_of Graph, g
+    assert_equal %w(a b c), g.nodes.keys.sort
   end
 
-  def test_global_attrib
-    expected = util_dot('"a" -> "b"')
-    assert_equal expected, @graph.to_s
+  def test_edge
+    @graph = Graph.new
 
-    @graph.global_attrib "color = blue"
+    graph.edge "a", "b", "c"
 
-    expected = util_dot('"a" [ color = blue ]',
-                        '"b" [ color = blue ]',
-                        '"a" -> "b"')
-    assert_equal expected, @graph.to_s
+    assert_graph graph, '"a" -> "b"', '"b" -> "c"'
   end
 
   def test_invert
-    @graph["a"] << "c"
-    invert = @graph.invert
-    assert_equal %w(a), invert["b"]
-    assert_equal %w(a), invert["c"]
+    graph["a"] >> "c"
+    invert = graph.invert
+    assert_equal %w(a), invert.edges["b"].keys
+    assert_equal %w(a), invert.edges["c"].keys
   end
 
-  def test_keys_by_count
-    @graph["a"] << "c"
-    @graph["d"] << "e" << "f" << "g"
-    assert_equal %w(d a), @graph.keys_by_count
-  end
+  def test_label
+    graph.label "blah"
 
-  def test_nodes
-    assert_equal %w(a),   @graph.keys.sort
-    assert_equal %w(a b), @graph.nodes.sort
+    assert_graph graph, 'label = "blah"', '"a" -> "b"'
   end
 
-  def test_normalize
-    @graph.clear
-    @graph["a"] << "b" << "b" << "b" # 3 edges from a to b
+  def test_left_shift
+    subgraph = Graph.new "blah"
 
-    expect = { "a" => %w(b b b) }
-    assert_equal expect, @graph
+    graph << subgraph
 
-    @graph.normalize                 # clear all but one edge
+    assert_equal graph, subgraph.graph
+    assert_includes graph.subgraphs, subgraph
+  end
 
-    expect = { "a" => %w(b) }
-    assert_equal expect, @graph
+  def test_nodes
+    assert_equal %w(a b), graph.nodes.keys.sort
   end
 
   def test_orient
-    @graph.orient "blah"
+    graph.orient "blah"
 
-    assert_equal ["rankdir = blah"], @graph.prefix
+    assert_equal ["rankdir = blah"], graph.graph_attribs
   end
 
   def test_orient_default
-    @graph.orient
-
-    assert_equal ["rankdir = TB"], @graph.prefix
-  end
+    graph.orient
 
-  def test_order
-    assert_equal %w(a), @graph.order
+    assert_equal ["rankdir = TB"], graph.graph_attribs
   end
 
   def test_rotate
-    @graph.rotate "blah"
+    graph.rotate "blah"
 
-    assert_equal ["rankdir = blah"], @graph.prefix
+    assert_equal ["rankdir = blah"], graph.graph_attribs
   end
 
   def test_rotate_default
-    @graph.rotate
+    graph.rotate
 
-    assert_equal ["rankdir = LR"], @graph.prefix
+    assert_equal ["rankdir = LR"], graph.graph_attribs
   end
 
   def test_save
@@ -129,39 +127,72 @@ class TestGraph < MiniTest::Unit::TestCase
     util_save nil
   end
 
+  def test_shape
+    assert_attribute "shape", "blah", graph.shape("blah")
+  end
+
+  def test_style
+    assert_attribute "style", "blah", graph.style("blah")
+  end
+
+  def test_subgraph
+    n = nil
+    s = graph.subgraph "blah" do
+      n = 42
+    end
+
+    assert_equal graph, s.graph
+    assert_equal "blah", s.name
+    assert_equal 42, n
+  end
+
   def test_to_s
-    expected = util_dot '"a" -> "b"'
-    assert_equal expected, @graph.to_s
+    assert_graph graph, '"a" -> "b"'
 
-    @graph["a"] << "c"
+    graph["a"] >> "c"
 
-    expected = util_dot '"a" -> "b"', '"a" -> "c"'
-    assert_equal expected, @graph.to_s
+    assert_graph graph, '"a" -> "b"', '"a" -> "c"'
   end
 
   def test_to_s_attrib
-    @graph.attribs["a"] << "color = blue"
-    @graph["a"] << "c"
+    graph.color("blue") << graph["a"]
 
-    expected = util_dot('"a" [ color = blue ]', '"a" -> "b"', '"a" -> "c"')
-    assert_equal expected, @graph.to_s
+    assert_graph graph, '"a" [ color = blue ]', '"a" -> "b"'
+  end
+
+  def test_to_s_edge_attribs
+    graph.edge_attribs << "blah" << "halb"
+
+    assert_graph graph, 'edge [ blah, halb ]', '"a" -> "b"'
   end
 
   def test_to_s_empty
-    assert_equal util_dot, Graph.new.to_s
+    assert_graph Graph.new
   end
 
-  def test_to_s_prefix
-    @graph.prefix << "blah"
-    @graph["a"] << "c"
+  def test_to_s_node_attribs
+    graph.node_attribs << "blah" << "halb"
 
-    expected = util_dot('blah', '"a" -> "b"', '"a" -> "c"')
-    assert_equal expected, @graph.to_s
+    assert_graph graph, 'node [ blah, halb ]', '"a" -> "b"'
   end
 
-  def util_dot(*lines)
-    lines = lines.map { |l| "    #{l};" }.join("\n")
-    "digraph absent\n  {\n#{lines}\n  }".sub(/\n\n/, "\n")
+  def test_to_s_subgraph
+    g = Graph.new "subgraph" do
+      edge "a", "c"
+    end
+
+    graph << g
+
+g_s = "subgraph subgraph
+  {
+    \"a\";
+    \"c\";
+    \"a\" -> \"c\";
+  }"
+
+    assert_graph(graph,
+                 g_s, # HACK: indentation is really messy right now
+                 '"a" -> "b"')
   end
 
   def util_save type
@@ -169,16 +200,122 @@ class TestGraph < MiniTest::Unit::TestCase
 
     $x = nil
 
-    def @graph.system(*args)
+    def graph.system(*args)
       $x = args
     end
 
-    @graph.save(path, type)
+    graph.save(path, type)
 
-    assert_equal @graph.to_s, File.read("#{path}.dot")
+    assert_equal graph.to_s, File.read("#{path}.dot")
     expected = ["dot -T#{type} #{path}.dot > #{path}.png"] if type
     assert_equal expected, $x
   ensure
     File.unlink path rescue nil
   end
 end
+
+class TestAttribute < MiniTest::Unit::TestCase
+  attr_accessor :a
+
+  def setup
+    self.a = Graph::Attribute.new "blah"
+  end
+
+  def test_lshift
+    n = Graph::Node.new nil, nil
+
+    a << n
+
+    assert_equal [a], n.attributes
+  end
+
+  def test_plus
+    b = Graph::Attribute.new "halb"
+
+    c = a + b
+
+    assert_equal "blah, halb", c.attr
+  end
+
+  def test_to_s
+    assert_equal "blah", a.to_s
+  end
+end
+
+class TestNode < MiniTest::Unit::TestCase
+  attr_accessor :n
+
+  def setup
+    self.n = Graph::Node.new :graph, "n"
+  end
+
+  def test_rshift
+    graph = Graph.new
+    self.n = graph.node "blah"
+
+    n2 = n >> "halb"
+    to = graph["halb"]
+    e = graph.edges["blah"]["halb"]
+
+    assert_equal n, n2
+    assert_kind_of Graph::Edge, e
+    assert_kind_of Graph::Node, to
+    assert_equal n, e.from
+    assert_equal to, e.to
+  end
+
+  def test_index
+    graph = Graph.new
+    self.n = graph.node "blah"
+
+    e = n["halb"]
+    to = graph["halb"]
+
+    assert_kind_of Graph::Edge, e
+    assert_kind_of Graph::Node, to
+    assert_equal n, e.from
+    assert_equal to, e.to
+  end
+
+  def test_label
+    n.label "blah"
+
+    assert_equal ["label = \"blah\""], n.attributes
+  end
+
+  def test_to_s
+    assert_equal '"n"', n.to_s
+  end
+
+  def test_to_s_attribs
+    n.attributes << "blah"
+
+    assert_equal '"n" [ blah ]', n.to_s.clean
+  end
+end
+
+class TestEdge < MiniTest::Unit::TestCase
+  attr_accessor :e
+
+  def setup
+    a = Graph::Node.new :graph, "a"
+    b = Graph::Node.new :graph, "b"
+    self.e = Graph::Edge.new :graph, a, b
+  end
+
+  def test_label
+    e.label "blah"
+
+    assert_equal ["label = \"blah\""], e.attributes
+  end
+
+  def test_to_s
+    assert_equal '"a" -> "b"', e.to_s
+  end
+
+  def test_to_s_attribs
+    e.attributes << "blah"
+
+    assert_equal '"a" -> "b" [ blah ]', e.to_s.clean
+  end
+end