iconofthestoneage-doodl 0.0.2 → 0.0.4

data/spec/graph_spec.rb

@@ -0,0 +1,269 @@
+# encoding: utf-8
+
+require 'rspec_helper'
+require 'enumerator'
+
+require "graph"
+require "edge"
+
+include Doodl
+
+describe "All Graphs", :shared  => true do
+
+  describe "Initialization" do
+    it "should be initinalized with empty nodes" do
+      @graph.nodes.should == []
+    end
+  end
+
+  describe "Convenience" do
+    it "should return whether it contains a node when sent contains_node?(node)" do
+      node1 = @graph.add_node
+      node2 = :node2
+      @graph.contains_node?(node1).should == true
+      @graph.contains_node?(node2).should == false
+    end
+
+    it "should return whether it contains an edge " do
+      a = @graph.add_node
+      b = @graph.add_node
+      edge = @graph.add_edge(a, b)
+      @graph.includes_edge?(edge).should == true
+      @graph.del_edge(edge)
+      @graph.includes_edge?(edge).should == false
+    end
+
+    it "should return the edge when sent get_edge(source, target)" do
+      a = @graph.add_node
+      b = @graph.add_node
+      c = @graph.add_node
+      edge = @graph.add_edge(a, b)
+      @graph.get_edge(a, b).should == edge
+      @graph.get_edge(a, c).should == nil
+    end
+  end
+
+  describe "MutableGraph" do
+    it "should add and return a new node when sent #add_node" do
+      a = @graph.add_node
+      a.is_a?(Node)
+      @graph.nodes.should == [a]
+    end
+    
+    it "should delete a node when sent #del_node(node)" do
+      a = @graph.add_node
+      @graph.del_node(a)
+      @graph.nodes.should == []
+    end
+    
+    it "should add and return an edge when sent #add_edge(source, target)" do
+      a, b = @graph.add_node, @graph.add_node
+      edge = @graph.add_edge(a, b)
+      edge.is_a?(Edge)
+      @graph.num_edges.should == 1
+    end
+    
+    it "should delete an edge when sent #del_edge(edge)" do
+      a, b = @graph.add_node, @graph.add_node
+      edge = @graph.add_edge(a, b)
+      @graph.del_edge(edge)
+      @graph.num_edges.should == 0
+    end
+
+  end
+
+  describe "NodeListGraph" do
+    it "should return the total number of nodes the graph contains when sent #num_nodes" do
+      @graph.should respond_to(:num_nodes)
+      @graph.num_nodes.should == 0
+      @graph.add_node
+      @graph.num_nodes.should == 1
+      @graph.add_node
+      @graph.num_nodes.should == 2
+    end
+
+    it "should return a Iterator that iterates the nodes when sent #each_node" do
+      @graph.should respond_to(:each_node)
+      n = @graph.add_node
+      m = @graph.add_node
+      e = Enumerable::Enumerator.new(@graph, :each_node)
+      e.to_a.should == [n, m]
+    end
+    
+    it "should return a Iterator that iterates the nodes with an index when sent #each_node_with_index" do
+      @graph.should respond_to(:each_node_with_index)
+      n = @graph.add_node
+      m = @graph.add_node
+      e = Enumerable::Enumerator.new(@graph, :each_node_with_index)
+      e.to_a.should == [[n, 0], [m, 1]]
+    end
+    
+  end    
+
+  describe "EdgeListGraph" do
+    it "should iterate all edges when sent #each_edge" do
+      @graph.should respond_to(:each_edge)
+      Enumerable::Enumerator.new(@graph, :each_edge).to_a.should == []
+      n = @graph.add_node
+      m = @graph.add_node
+      o = @graph.add_node
+      e = @graph.add_edge(n, m)
+      Enumerable::Enumerator.new(@graph, :each_edge).to_a.should == [e]
+      f = @graph.add_edge(m, o)
+      Enumerable::Enumerator.new(@graph, :each_edge).to_a.should == [e, f]
+    end
+
+    it "should reveal the source of an edge" do
+      @graph.should respond_to(:source)
+      n = @graph.add_node
+      m = @graph.add_node
+      e = @graph.add_edge(n, m)
+      @graph.source(e).should == n
+    end
+
+    it "should reveal the target of an edge" do
+      @graph.should respond_to(:target)
+      n = @graph.add_node
+      m = @graph.add_node
+      e = @graph.add_edge(n, m)
+      @graph.target(e).should == m
+    end
+
+  end
+
+  describe "IncidentGraph" do
+    it "should return the outdegree of a node when sent #out_degree" do
+      a = @graph.add_node
+      b = @graph.add_node
+      @graph.out_degree(a).should == 0
+      @graph.add_edge(a, b)
+      @graph.out_degree(a).should == 1
+    end
+
+    it "should iterate all outgoing edges of a graph" do
+      a = @graph.add_node
+      b = @graph.add_node
+      Enumerable::Enumerator.new(@graph, :each_adjacent_node, a).to_a.should == []
+      e = @graph.add_edge(a, b)
+      Enumerable::Enumerator.new(@graph, :each_adjacent_edge, a).to_a.should == [e]
+    end
+  end
+
+  describe "AdjacentGraph" do
+    it "should iterate all adjacent nodes" do
+      a = @graph.add_node
+      b = @graph.add_node
+      Enumerable::Enumerator.new(@graph, :each_adjacent_node, a).to_a.should == []
+      e = @graph.add_edge(a, b)
+      Enumerable::Enumerator.new(@graph, :each_adjacent_node, a).to_a.should == [b]
+    end
+  end
+
+  describe "Filtering Iterator, an iterator that filters with an lambda argument" do
+
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @c = @graph.add_node
+    end
+
+    it "should return every node if condition is lambda { true }" do
+      c = lambda { true }
+      result = []
+      @graph.each_node_passing(c) { |node| result << node  }
+      result.should == [@a, @b, @c]
+    end
+
+    it "should return no node if condition is lambda { false }" do
+      c = lambda { false }
+      result = []
+      @graph.each_node_passing(c) { |node| result << node  }
+      result.should == []
+    end
+
+    it "should return @a if condition tests for existence of @a" do
+      c = lambda { |node| node == @a }
+      result = []
+      @graph.each_node_passing(c) { |node| result << node  }
+      result.should == [@a]      
+    end
+
+  end
+
+  describe "Adding edges to the graph via #add_edge(source, target)" do
+
+    it "should raise an ArgumentError if either source or target or both are not nodes of the graph" do
+      other_graph = DirectedGraph.new
+      other_source = other_graph.add_node
+      other_target = other_graph.add_node
+      source = @graph.add_node
+      target = @graph.add_node
+      lambda { @graph.add_edge(other_source, other_target) }.should raise_error(ArgumentError)
+      lambda { @graph.add_edge(other_source, target) }.should raise_error(ArgumentError)
+      lambda { @graph.add_edge(source, other_target) }.should raise_error(ArgumentError)
+      lambda { @graph.add_edge(source, target) }.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an ArgumentError if there is already an edge (source->target) defined" do
+      source = @graph.add_node
+      target = @graph.add_node
+      @graph.add_edge(source, target)
+      lambda { @graph.add_edge(source, target) }.should raise_error(ArgumentError)
+    end
+
+  end
+
+end
+
+describe DirectedGraph do
+  
+  before(:each) do
+    @graph = DirectedGraph.new
+  end
+  
+  it_should_behave_like "All Graphs"
+  
+  it "should be directed" do
+    @graph.directed?.should == true
+  end
+
+  it "should NOT raise an ArgumentError if there is already a mirroring edge (target->source) defined" do
+    source = @graph.add_node
+    target = @graph.add_node
+    @graph.add_edge(target, source)
+    lambda { @graph.add_edge(source, target) }.should_not raise_error(ArgumentError)
+  end
+
+end
+
+describe UndirectedGraph do
+
+  before(:each) do
+    @graph = UndirectedGraph.new
+  end
+
+  it_should_behave_like "All Graphs"
+
+  it "should be undirected" do
+    @graph.directed?.should == false
+  end
+  
+  it "should hava undirected edges" do
+    a = @graph.add_node
+    b = @graph.add_node
+    e = @graph.add_edge(a, b)
+    e.directed?.should == false
+  end
+  
+  it "should return adjacent_edges and nodes" do
+    a = @graph.add_node
+    b = @graph.add_node
+    c = @graph.add_node
+    e = @graph.add_edge(a, b)
+    Enumerable::Enumerator.new(@graph, :each_adjacent_edge, a).to_a.should == [e]
+    Enumerable::Enumerator.new(@graph, :each_adjacent_edge, b).to_a.should == [e]
+    Enumerable::Enumerator.new(@graph, :each_adjacent_node, a).to_a.should == [b]
+    Enumerable::Enumerator.new(@graph, :each_adjacent_node, b).to_a.should == [a]
+  end
+
+end

data/spec/jruby/renderer_spec.rb

@@ -0,0 +1,214 @@
+# encoding: utf-8
+
+require 'rspec_helper'
+
+require 'renderer'
+
+include Doodl
+
+describe PluggableRenderer do
+  before(:each) do
+    @graph = mock("graph")
+    @renderer = PluggableRenderer.new
+  end
+
+  describe "Node Functions" do
+
+    it "should accept node predicates" do
+      lambda { @renderer.node_predicate_function = mock("predicate") }.should_not raise_error(Exception)
+    end
+
+    it "should accept node_predicate with a block defining the predicate" do
+      @renderer.node_predicate_function { true }
+      @renderer.node_predicate(mock("node")).should == true
+    end
+
+    it "should call the node_predicate, when sent #node_predicate" do
+      node = mock("node")
+      predicate = mock("predicate")
+      predicate.should_receive(:call).with(nil, nil, node)
+      @renderer.node_predicate_function = predicate
+      @renderer.node_predicate(node)
+    end
+
+    it "should return true/false when node_predicate.call(graph, node) returns true/false" do
+      n = mock("painted node")
+      m = mock("not painted node")
+      predicate = mock("predicate")
+      predicate.should_receive(:call).with(nil, nil, n).once.and_return(true)
+      @renderer.node_predicate_function = predicate
+      @renderer.node_predicate(n).should == true
+      predicate.should_receive(:call).with(nil, nil, m).once.and_return(false)
+      @renderer.node_predicate(m).should == false
+    end
+
+    it "should raise an ArgumentError when #node_shape_function is called without a block" do
+      lambda { @renderer.node_shape_function }.should raise_error(ArgumentError)
+      lambda { @renderer.node_shape_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a node_shape_fuction when sent #node_shape_fuction=" do
+      lambda { @renderer.node_shape_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by node_shape_function when sent #node_shape(node)" do
+      n = mock("node a")
+      m = mock("node b")
+      shape = mock("shape")
+      @renderer.node_shape_function = lambda { shape }
+      @renderer.node_shape(n).should == shape
+      @renderer.node_shape_function = lambda { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_shape(n).should == :n
+      @renderer.node_shape(m).should == :m
+      @renderer.node_shape_function { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_shape(n).should == :n
+      @renderer.node_shape(m).should == :m
+    end
+
+    it "should raise an ArgumentError when #node_stroke_color_function is called without a block" do
+      lambda { @renderer.node_stroke_color_function }.should raise_error(ArgumentError)
+      lambda { @renderer.node_stroke_color_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a node_shape_fuction when sent #node_shape_fuction=" do
+      lambda { @renderer.node_stroke_color_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by node_stroke_color_function when sent #node_shape(node)" do
+      n = mock("node a")
+      m = mock("node b")
+      color = mock("color")
+      @renderer.node_stroke_color_function = lambda { color }
+      @renderer.node_stroke_color(n).should == color
+      @renderer.node_stroke_color_function = lambda { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_stroke_color(n).should == :n
+      @renderer.node_stroke_color(m).should == :m
+      @renderer.node_stroke_color_function { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_stroke_color(n).should == :n
+      @renderer.node_stroke_color(m).should == :m
+    end
+
+    it "should retun the shape defined by node_shape_function when sent #node_shape(node)" do
+      n = mock("node a")
+      m = mock("node b")
+      shape = mock("shape")
+      @renderer.node_shape_function = lambda { shape }
+      @renderer.node_shape(n).should == shape
+      @renderer.node_shape_function = lambda { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_shape(n).should == :n
+      @renderer.node_shape(m).should == :m
+      @renderer.node_shape_function { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_shape(n).should == :n
+      @renderer.node_shape(m).should == :m
+    end
+
+    it "should raise an ArgumentError when #node_stroke_color_function is called without a block" do
+      lambda { @renderer.node_stroke_color_function }.should raise_error(ArgumentError)
+      lambda { @renderer.node_stroke_color_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a node_shape_fuction when sent #node_shape_fuction=" do
+      lambda { @renderer.node_stroke_color_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by node_stroke_color_function when sent #node_shape(node)" do
+      n = mock("node a")
+      m = mock("node b")
+      color = mock("color")
+      @renderer.node_stroke_color_function = lambda { color }
+      @renderer.node_stroke_color(n).should == color
+      @renderer.node_stroke_color_function = lambda { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_stroke_color(n).should == :n
+      @renderer.node_stroke_color(m).should == :m
+      @renderer.node_stroke_color_function { |graph, layout, node| node == n ? :n : :m }
+      @renderer.node_stroke_color(n).should == :n
+      @renderer.node_stroke_color(m).should == :m
+    end
+  end
+
+  describe "Edge Functions" do
+    it "should raise an ArgumentError when #edge_shape_function is called without a block" do
+      lambda { @renderer.edge_shape_function }.should raise_error(ArgumentError)
+      lambda { @renderer.edge_shape_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a edge_shape_fuction when sent #edge_shape_fuction=" do
+      lambda { @renderer.edge_shape_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by edge_shape_function when sent #edge_shape(edge)" do
+      n = mock("edge a")
+      m = mock("edge b")
+      shape = mock("shape")
+      @renderer.edge_shape_function = lambda { shape }
+      @renderer.edge_shape(n).should == shape
+      @renderer.edge_shape_function = lambda { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_shape(n).should == :n
+      @renderer.edge_shape(m).should == :m
+      @renderer.edge_shape_function { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_shape(n).should == :n
+      @renderer.edge_shape(m).should == :m
+    end
+
+    it "should raise an ArgumentError when #edge_stroke_color_function is called without a block" do
+      lambda { @renderer.edge_stroke_color_function }.should raise_error(ArgumentError)
+      lambda { @renderer.edge_stroke_color_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a edge_shape_fuction when sent #edge_shape_fuction=" do
+      lambda { @renderer.edge_stroke_color_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by edge_stroke_color_function when sent #edge_shape(edge)" do
+      n = mock("edge a")
+      m = mock("edge b")
+      color = mock("color")
+      @renderer.edge_stroke_color_function = lambda { color }
+      @renderer.edge_stroke_color(n).should == color
+      @renderer.edge_stroke_color_function = lambda { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_stroke_color(n).should == :n
+      @renderer.edge_stroke_color(m).should == :m
+      @renderer.edge_stroke_color_function { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_stroke_color(n).should == :n
+      @renderer.edge_stroke_color(m).should == :m
+    end
+
+    it "should retun the shape defined by edge_shape_function when sent #edge_shape(edge)" do
+      n = mock("edge a")
+      m = mock("edge b")
+      shape = mock("shape")
+      @renderer.edge_shape_function = lambda { shape }
+      @renderer.edge_shape(n).should == shape
+      @renderer.edge_shape_function = lambda { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_shape(n).should == :n
+      @renderer.edge_shape(m).should == :m
+      @renderer.edge_shape_function { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_shape(n).should == :n
+      @renderer.edge_shape(m).should == :m
+    end
+
+    it "should raise an ArgumentError when #edge_stroke_color_function is called without a block" do
+      lambda { @renderer.edge_stroke_color_function }.should raise_error(ArgumentError)
+      lambda { @renderer.edge_stroke_color_function(:dodo) }.should raise_error(ArgumentError)
+    end
+
+    it "should accept a edge_shape_fuction when sent #edge_shape_fuction=" do
+      lambda { @renderer.edge_stroke_color_function = mock("shape_fuction") }.should_not raise_error(Exception)
+    end
+
+    it "should retun the shape defined by edge_stroke_color_function when sent #edge_shape(edge)" do
+      n = mock("edge a")
+      m = mock("edge b")
+      color = mock("color")
+      @renderer.edge_stroke_color_function = lambda { color }
+      @renderer.edge_stroke_color(n).should == color
+      @renderer.edge_stroke_color_function = lambda { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_stroke_color(n).should == :n
+      @renderer.edge_stroke_color(m).should == :m
+      @renderer.edge_stroke_color_function { |graph, layout, edge| edge == n ? :n : :m }
+      @renderer.edge_stroke_color(n).should == :n
+      @renderer.edge_stroke_color(m).should == :m
+    end
+  end
+
+end