jumoku 0.2.0 → 0.2.1

data/vendor/git/plexus/spec/digraph_spec.rb

@@ -1,339 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe "Digraph" do # :nodoc:
-
-  before do
-    @single = Digraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
-    @dups   = DirectedPseudoGraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
-    @loops  = DirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
-  end
-
-  describe "new" do
-    it do
-      @single.should == Digraph[1,2, 2,3, 3,4]
-      @dups.should == DirectedPseudoGraph.new([1,2, 2,3, 3,4, 1,2, 2,3])
-      @loops.should == DirectedMultiGraph.new([1,2, 2,3, 3,4, 4,4, 1,2, 2,3])
-      proc { Digraph.new(:loops) }.should raise_error(ArgumentError)
-      proc { Digraph.new(:parallel_edges) }.should raise_error(ArgumentError)
-      proc { DirectedMultiGraph.new(:loops) }.should raise_error(ArgumentError)
-      proc { DirectedMultiGraph.new(:parallel_edges) }.should raise_error(ArgumentError)
-      proc { DirectedPseudoGraph.new(:loops) }.should raise_error(ArgumentError)
-      proc { DirectedPseudoGraph.new(:parallel_edges) }.should raise_error(ArgumentError)
-      proc { Digraph.new(1) }.should raise_error(ArgumentError)
-      Digraph.new(@single).should == @single
-      DirectedPseudoGraph.new(@dups).should == @dups
-      DirectedMultiGraph.new(@loops).should == @loops
-      Digraph.new(@loops).should == Digraph[1,2, 2,3, 3,4]
-    end
-  end
-
-  describe "edges" do
-    it do
-      @single.edges.size.should == 3
-      @single.edges.include?(Arc[1,2]).should be_true
-      @single.edges.include?(Arc[2,3]).should be_true
-      @single.edges.include?(Arc[3,4]).should be_true
-      @single.edges.include?(Arc[4,4]).should be_false
-      @single.edges.include?(Arc[1,2]).should be_true
-      @single.edges.include?(Arc[2,3]).should be_true
-      @single.edges.include?(Arc[1,3]).should be_false
-      @single.edge?(2,3).should be_true
-      @single.edge?(1,4).should be_false
-      @single.edge?(Arc[1,2]).should be_true
-      @single.add_edge!(5,5).edge?(5,5).should be_false
-      @single.remove_edge!(5,5).edge?(5,5).should be_false
-
-      @dups.edges.size.should == 5
-      @dups.edges.include?(MultiArc[1,2]).should be_true
-      @dups.edges.include?(MultiArc[2,3]).should be_true
-      @dups.edges.include?(MultiArc[3,4]).should be_true
-      @dups.edges.include?(MultiArc[4,4]).should be_false
-      @dups.edges.include?(MultiArc[1,2]).should be_true
-      @dups.edges.include?(MultiArc[2,3]).should be_true
-      @dups.edges.include?(MultiArc[1,3]).should be_false
-      @dups.edge?(2,3).should be_true
-      @dups.edge?(1,4).should be_false
-      @dups.edge?(MultiArc[1,2]).should be_true
-      @dups.add_edge!(5,5).edge?(5,5).should be_false
-      proc {  @dups.remove_edge!(5,5)  }.should raise_error(ArgumentError)
-
-      @dups.edges.size.should == 5 
-      @loops.edges.include?(MultiArc[1,2]).should be_true
-      @loops.edges.include?(MultiArc[2,3]).should be_true
-      @loops.edges.include?(MultiArc[3,4]).should be_true
-      @loops.edges.include?(MultiArc[4,4]).should be_true
-      @loops.edges.include?(MultiArc[1,2]).should be_true
-      @loops.edges.include?(MultiArc[2,3]).should be_true
-      @loops.edges.include?(MultiArc[1,3]).should be_false
-      @loops.edge?(2,3).should be_true
-      @loops.edge?(1,4).should be_false
-      @loops.edge?(MultiArc[1,2]).should be_true
-      @loops.add_edge!(5,5).edge?(5,5).should be_true
-      proc {  @loops.remove_edge!(5,5)  }.should raise_error(ArgumentError)
-    end
-
-  end
-
-  describe "vertices" do
-    it do
-        @single.vertices.sort.should == [1,2,3,4]
-      @single.add_vertex!(5).to_a.sort.should == [1,2,3,4,5]
-        @single.remove_vertex!(3).to_a.sort.should == [1,2,4,5]
-      @single.vertex?(3).should be_false
-      @single.edge?(2,3).should be_false
-      @single.edge?(3,4).should be_false
-      @single.add_vertex(:bogus).vertex?(:bogus).should be_true
-      @single.add_vertex(:bogus).vertex?(nil).should be_false
-      @single.vertex?(:bogus).should be_false
-      @single.add_vertex!(:real)
-      @single.vertex?(:real).should be_true
-      @single.add_edge(:here, :there).edge?(Arc[:here, :there]).should be_true
-      @single.edge?(Arc[:here, :there]).should be_false
-      @single.vertex?(:here).should be_false
-      @single.vertex?(:there).should be_false
-      @single.add_edge!(:here, :there)
-      @single.edge?(Arc[:here, :there]).should be_true
-      @single.vertex?(:here).should be_true
-      @single.vertex?(:there).should be_true
-    end
-  end
-
-  describe "properties" do
-    it do
-      @single.should be_directed
-      @single.should_not be_empty
-      Digraph.new.should be_empty
-      @single.size.should == 4
-      @dups.size.should == 4
-      @loops.size.should == 4
-      @single.num_vertices.should == 4
-      @dups.num_vertices.should == 4
-      @single.num_edges.should == 3
-      @dups.num_edges.should == 5
-      @loops.num_edges.should == 6
-      @single.should be_oriented
-      @single.remove_vertex!(4)
-      @single.should be_oriented
-      @loops.oriented?.should be_false
-      @loops.remove_vertex!(4)
-      @loops.should be_oriented
-    end
-  end
-
-  describe "merge" do
-    it do
-      @dups.merge(@single)
-      @dups.num_edges.should == 8
-      @dups.vertices.sort.should == [1,2,3,4]
-    end
-  end
-
-  describe "operators" do
-    it do
-      result = @single + Arc[3,2] 
-      @single.size.should == 4
-      @single.num_edges.should == 3
-      result.size.should == 4
-      result.num_edges.should == 4
-
-      result = @single + 5
-      @single.size.should == 4
-      @single.num_edges.should == 3
-      result.size.should == 5
-      result.num_edges.should == 3
-
-      result = @single - Arc[4,4]
-      @single.size.should == 4
-      @single.num_edges.should == 3
-      result.size.should == 4
-      result.num_edges.should == 3
-
-      e = @loops.edges.detect { |e| e.source == 4 && e.target == 4 }
-      result = @loops - e
-      @single.size.should == 4
-      @single.num_edges.should == 3
-      result.size.should == 4
-      result.num_edges.should == 5
-
-      result = @single - 4
-      @single.size.should == 4
-      @single.num_edges.should == 3
-      result.size.should == 3
-      result.num_edges.should == 2
-      
-      @single << Arc[6,1]
-      @single.size.should == 5
-      @single.num_edges.should == 4
-      @single.edge?(6,1).should be_true
-    end
-  end
-
-  describe "reversal" do
-    it do
-      reverse = @single.add_vertex!(42).reversal
-      reverse.vertices.sort.should == [1,2,3,4,42]
-      reverse.edge?(2,1).should be_true
-      reverse.edge?(3,2).should be_true
-      reverse.edge?(4,3).should be_true
-      reverse.edge?(4,4).should be_false
-      reverse.num_edges.should == 3
-      reverse = @loops.reversal
-      reverse.edge?(4,4).should be_true
-    end
-  end
-
-  describe "complement" do
-    it do
-      complement = @single.complement 
-      complement.vertices.sort.should == [1,2,3,4]
-      complement.edge?(1,1).should be_false
-      complement.edge?(1,3).should be_true
-      complement.edge?(1,4).should be_true
-      complement.edge?(2,1).should be_true
-      complement.edge?(2,4).should be_true
-      complement.edge?(3,1).should be_true
-      complement.edge?(3,2).should be_true
-      complement.edge?(4,1).should be_true
-      complement.edge?(4,2).should be_true
-      complement.edge?(4,3).should be_true
-      complement.num_edges.should == 9
-
-      complement = @loops.complement 
-      complement.vertices.sort.should == [1,2,3,4]
-      complement.edge?(1,1).should be_true
-      complement.edge?(1,3).should be_true
-      complement.edge?(1,4).should be_true
-      complement.edge?(2,1).should be_true
-      complement.edge?(2,2).should be_true
-      complement.edge?(2,4).should be_true
-      complement.edge?(3,1).should be_true
-      complement.edge?(3,2).should be_true
-      complement.edge?(3,3).should be_true
-      complement.edge?(4,1).should be_true
-      complement.edge?(4,2).should be_true
-      complement.edge?(4,3).should be_true
-      complement.num_edges.should == 12
-    end
-  end
-
-  describe "induced_subgraph" do
-    it do
-      induced = @single.induced_subgraph([1,2])
-      induced.vertices.sort.should == [1,2]
-      induced.edge?(1,2).should be_true
-      induced.num_edges.should == 1
-    end
-  end
-
-  describe "include" do
-    it do
-      @single.include?(4).should be_true
-      @dups.include?(4).should be_true
-      @dups.include?(5).should be_false
-      @single.include?(5).should be_false
-      @single.include?(Arc[1,2]).should be_true
-      @dups.include?(Arc[1,2]).should be_true
-    end
-  end
-
-  describe "adjacent" do
-    it do
-
-      @single.adjacent?(2, Arc[1,2]).should be_true
-      @single.adjacent(1).should == [2]
-
-      @single.adjacent(1, :type=>:edges).should == [Arc[1,2]]
-      @single.adjacent(1, :type=>:edges, :direction=> :out).should == [Arc[1,2]]
-      @single.adjacent(2, :type=>:edges, :direction=> :in).should == [Arc[1,2]]
-      @single.adjacent(2, :type=>:edges, :direction=> :all).sort.should == [Arc[1,2],Arc[2,3]]
-
-      [[{},1], [{:direction => :out},1], [{:direction => :in},2]].each do |h,v|
-        adj = @dups.adjacent(v, h.merge(:type=>:edges))
-        adj.size.should == 2
-        adj.each do |e|
-          e.source == 1; e.target.should  == 2
-        end
-      end 
-      
-      adj = @dups.adjacent(2, {:type=>:edges,:direction=>:all})
-      adj.size.should == 4
-      adj.each do |e| 
-        ((e.source==1 and e.target==2) ||
-         (e.source==2 and e.target==3)).should be_true
-      end
-      
-        @single.adjacent(1, :type=>:vertices).should == [2]
-        @single.adjacent(1, :type=>:vertices, :direction=> :out).should == [2]
-        @single.adjacent(2, :type=>:vertices, :direction=> :in).should == [1]
-      @single.adjacent(2, :type=>:vertices, :direction=> :all).should == [1,3]
-
-      @single.adjacent(Arc[2,3], :type=>:vertices).should == [3]
-      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :out).should == [3]
-      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :in).should == [2]
-      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :all).should == [2,3]
-
-      @single.adjacent(Arc[2,3], :type=>:edges).should == [Arc[3,4]]
-      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :out).should == [Arc[3,4]]
-      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :in).should == [Arc[1,2]]
-      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :all).sort.should == [Arc[1,2],Arc[3,4]]
-      
-      @dups.adjacent(MultiArc[2,3], :type=>:edges).should == [MultiArc[3,4]]
-      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :out).should == [MultiArc[3,4]]
-      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :in).should == [MultiArc[1,2]]*2
-      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :all).sort.should == ([MultiArc[1,2]]*2+[MultiArc[3,4]])
-    end
-    
-  end
-
-  describe "neighborhood" do
-    it do
-      @single.neighborhood(1).sort.should == [2]
-      @single.neighborhood(2).sort.should == [1,3]
-      @single.neighborhood(Arc[2,3]).sort.should == [Arc[1,2], Arc[3,4]]
-    end
-  end
-
-  describe "degree" do
-    it do
-      @single.in_degree(1).should == 0
-      @single.in_degree(2).should == 1
-      @single.in_degree(4).should == 1
-      @loops.degree(4).should == 3
-      @loops.in_degree(4).should == 2
-      @single.out_degree(1).should == 1
-      @single.out_degree(2).should == 1
-      @single.out_degree(4).should == 0
-      @loops.out_degree(4).should == 1
-      @single.add_vertex!(6).out_degree(6).should == 0
-      @single.add_vertex!(7).in_degree(7).should == 0
-      @single.add_edge!(4,2).out_degree(4).should == 1
-      @loops.add_edge!(4,2).out_degree(4).should == 2
-      @single.in_degree(2).should == 2
-
-      @single.min_in_degree.should == 0
-      @single.max_in_degree.should == 2
-      @single.min_out_degree.should == 0
-      @single.max_out_degree.should == 1
-
-      @loops.min_in_degree.should == 0
-      @loops.max_in_degree.should == 2
-      @loops.min_out_degree.should == 1
-      @loops.max_out_degree.should == 2
-      @loops.degree(2).should == 4
-      @single.degree(1).should == 1
-      @loops.should_not be_regular
-      @single.should_not be_regular
-      @dups.should_not be_regular
-    end
-  end
-
-  describe "include" do
-    it do
-      @single.include?(2).should be_true
-      @single.include?(23).should be_false
-      @single.include?(Arc[1,2]).should be_true
-      @single.include?(Arc[1,4]).should be_false
-    end
-  end
-
-end

data/vendor/git/plexus/spec/dot_spec.rb

@@ -1,48 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe "Dot" do # :nodoc:
-  
-  DG_DOT = <<-DOT
-digraph  {
-    label = "Datacenters"
-    Miranda [
-        color = green,
-        style = filled,
-        label = "Miranda"
-    ]
-
-    Miranda -> Hillview [
-
-    ]
-
-    Miranda -> "San Francisco" [
-
-    ]
-
-    Miranda -> "San Jose" [
-
-    ]
-
-    Sunnyvale -> Miranda [
-
-    ]
-
-}
-DOT
-  
-  before do
-    @dg = DOT::DOTDigraph.new('label' => 'Datacenters')
-    @dg << DOT::DOTNode.new('name' => 'Miranda', 'color' => 'green', 'style' => 'filled')
-    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => 'Hillview')
-    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => '"San Francisco"')
-    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => '"San Jose"')
-    @dg << DOT::DOTDirectedArc.new('from' => 'Sunnyvale', 'to' => 'Miranda')
-  end
-  
-  describe "generation" do
-    it do
-      @dg.to_s.should == DG_DOT
-    end
-  end
-  
-end

data/vendor/git/plexus/spec/edge_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-describe Arc do
-  before do
-    @e = Arc.new(1,2,'boo')
-    @u = Edge.new(1,2,'hoo')
-  end
-
-  describe "#edge_new" do
-    it do
-      proc { Arc.new }.should raise_error(ArgumentError)
-      proc { Arc.new(1) }.should raise_error(ArgumentError)
-      Arc.new(1,2).should be_a_kind_of(Arc)
-      Arc.new(1,2,'label').should be_a_kind_of(Arc)
-    end
-  end
-
-  describe "#edge_getters" do
-    it do
-      @e.source.should == 1
-      @e.target.should == 2
-      @e.label.should == 'boo'
-
-      @e[0].should == 1
-      @e[1].should == 2
-      @e[2].should == 'boo'
-
-      @e[-3].should == 1
-      @e[-2].should == 2
-      @e[-1].should == 'boo'
-
-      proc { @e[-4] }.should raise_error(IndexError)
-      proc { @e[3] }.should raise_error(IndexError)
-
-      @e['source'].should == 1
-      @e['target'].should == 2
-      @e['label'].should == 'boo'
-
-      @e[:source].should == 1
-      @e[:target].should == 2
-      @e[:label].should == 'boo'
-    end
-  end
-
-  describe "#edge_setters" do
-    it do
-      @e.source = 23
-      @e.target = 42
-      @e.label  = 'Yabba'
-      @e.source.should == 23
-      @e.target.should == 42
-      @e.label.should == 'Yabba'
-
-      @e['source'] = 2
-      @e['target'] = 1
-      @e['label']  = 'Dabba'
-      @e.source.should == 2
-      @e.target.should == 1
-      @e.label.should == 'Dabba'
-
-      @e[:source] = 9
-      @e[:target] = 8
-      @e['label'] = 'Doooo!'
-      @e.source.should == 9
-      @e.target.should == 8
-      @e.label.should == 'Doooo!'
-
-      @e[0] = 'Fred'
-      @e[1] = 'Flintstone'
-      @e[2] = 'and'
-      @e.source.should == 'Fred'
-      @e.target.should == 'Flintstone'
-      @e.label.should == 'and'
-
-      @e[-3] = 'Barney'
-      @e[-2] = 'Rubble'
-      @e[-1] = nil
-      @e.source.should == 'Barney'
-      @e.target.should == 'Rubble'
-      @e.label.should == nil
-    end
-  end
-
-  describe "#edge_simple_methods" do
-    it do
-      @e.to_a.should == [1,2,'boo']
-      @e.to_s.should == "(1-2 'boo')"
-      @e.label = nil
-      @e.to_s.should == "(1-2)"
-      @e.eql?(Arc.new(1,2)).should be_true
-      @e.eql?(Arc.new(1,3)).should be_false
-      Arc.new(2,1).eql?(@e).should be_false
-
-      @e.should == Arc.new(1,2)
-      @e.reverse.should == Arc.new(2,1)
-      Arc.new(1,2).should_not == Arc.new(1,3)
-      Arc.new(2,1).should_not == @e
-    end
-  end
-
-  describe "#edge_sort" do
-    it do
-      x = [ Arc.new(2,3), Arc.new(1,3), Arc.new(1,2), Arc.new(2,1) ].sort
-      x.should == [Arc.new(1,2), Arc.new(1,3), Arc.new(2,1), Arc.new(2,3)]
-    end
-  end
-
-  describe "#undirected_edge_new" do
-    it do
-      proc { Edge.new }.should raise_error(ArgumentError)
-      proc { Edge.new(1) }.should raise_error(ArgumentError)
-      Edge.new(1,2).should be_a_kind_of(Edge)
-      Edge.new(1,2,'label').should be_a_kind_of(Edge)
-    end
-  end
-
-  describe "#undirected_edge_getters" do
-    it do
-      @u.source.should == 1
-      @u.target.should == 2
-      @u.to_a.should == [1,2,'hoo']
-      @u.to_s.should == "(1=2 'hoo')"
-    end
-  end
-
-  describe "#undirected_edge_methods" do
-    it do
-      @u.label = nil
-      @u.to_s.should == "(1=2)"
-      Edge.new(2,1).to_s.should == "(1=2)"
-
-      @u.should == Edge.new(2,1)
-      @u.should == Edge.new(2,1,'boo')
-      @u.should_not == Edge.new(2,3)
-
-      Edge.new(2,1).hash.should == @u.hash
-    end
-  end
-
-  describe "#undirected_edge_sort" do
-    it do
-      x = [Edge.new(12, 1), Edge.new(2,11)].sort
-      x.should == [Edge.new(2,11), Edge.new(1,12)]
-    end
-  end
-
-  describe "#hash" do
-    it do
-      Arc[1,2,:c].should == Arc[1,2,:b]
-      Arc[1,2,:c].hash.should == Arc[1,2,:b].hash
-      Arc[1,2].should_not == Arc[2,1]
-      Arc[1,2].should_not == Edge[1,2]
-      Edge[1,2].should == Edge[2,1]
-      Edge[1,2,:a].should == Edge[2,1,:b]
-    end
-  end
-
-end