graphs 0.1.2-x86-linux → 0.1.3-x86-linux

data/lib/graph.rb

@@ -5,6 +5,80 @@ require 'yaml'
 # A graph with nodes and edges
 class Graph
 
+    # Return a new Graph which is the intersection of every given graphs.
+    # Each node of the intersection is in every given graph (idem for edges).
+    # The last argument may be a hash of options.
+    # @option options [Boolean] :same_fields use only fields which are in every
+    # graph to perform the intersection
+    # @see Graph#&
+    def Graph::intersection(*graphs)
+        return nil if graphs.length == 0
+
+        opts = {}
+
+        if graphs[-1].is_a?(Hash)
+            return nil if graphs.length == 1
+            opts.update(graphs.pop)
+        end
+
+        graphs.each {|g|
+            if (!g.is_a?(Graph))
+                return nil
+            end
+        }
+
+        if opts[:same_fields]
+            graphs.map! {|g| g.clone}
+
+            # every first node of every graphs
+            nodes_ref = graphs.map {|g| g.nodes[0] || {}}
+            # every first edge of every graphs
+            edges_ref = graphs.map {|g| g.edges[0] || {}}
+
+            nodes_keys_ref = nodes_ref.map {|n| n.keys}
+            edges_keys_ref = edges_ref.map {|e| e.keys}
+
+            # keep only same keys
+            nodes_keys_uniq = nodes_keys_ref.inject {|i,e| i &= e}
+            edges_keys_uniq = edges_keys_ref.inject {|i,e| i &= e}
+
+            graphs.map! {|g|
+                g.nodes.map! { |n|
+                    
+                    newnode = {}
+
+                    n.each_key { |k|
+                        newnode[k] = n[k] if nodes_keys_uniq.include?(k)
+                    }
+
+                    newnode
+                }
+                g.edges.map! { |n|
+                    
+                    newedge = {}
+
+                    n.each_key { |k|
+                        newedge[k] = n[k] if edges_keys_uniq.include?(k)
+                    }
+
+                    newedge
+                }
+                g
+            }
+
+        elsif graphs.length == 2
+            return graphs[0] & graphs[1]
+        end 
+
+        graph = graphs.shift.clone
+
+        graphs.each { |g|
+            graph &= g
+        }
+
+        return graph
+    end
+
     # An array of nodes, each node is an hash of label/value paires
     class NodeArray < Array
 
@@ -70,6 +144,18 @@ class Graph
         Graph.new(nodes, edges)
     end
 
+    # Clone the current graph. All nodes and edges are also cloned.
+    def clone()
+        g = Graph.new
+        g.nodes = self.nodes.clone
+        g.edges = self.edges.clone
+
+        g.nodes.map! {|h| h.clone}
+        g.edges.map! {|h| h.clone}
+
+        g
+    end
+
     # Write the current Graph into a file.
     # @param filename [String] A valid filename
     # @param opts [Hash] A customizable set of options

data/tests/tests_graph.rb

@@ -34,6 +34,105 @@ class Graph_test < Test::Unit::TestCase
         ]
     )
 
+    # == Graph::intersection == #
+
+    def test_intersection_no_graphs
+        assert_equal(nil, Graph::intersection)
+        assert_equal(nil, Graph::intersection({:same_fields => true}))
+    end
+
+    def test_intersection_2_empty_graphs
+        g = Graph.new
+        h = g.clone
+
+        assert_equal(h, Graph::intersection(g, g))
+    end
+
+    def test_intersection_4_empty_graphs_intersection
+        g = Graph.new
+        h = g.clone
+
+        assert_equal(h, Graph::intersection(g, g, g, g))
+    end
+
+    def test_intersection_one_node_graph_and_empty_graph
+        g = Graph.new([{'label'=>'foo'}])
+        empty = Graph.new
+        empty2 = empty.clone
+
+        assert_equal(empty2, Graph::intersection(g, empty))
+    end
+
+    def test_intersection_sample_graph_and_itself_5_times
+        g = @@sample_graph
+        h = g.clone
+
+        assert_equal(h, Graph::intersection(g, g, g, g, g))
+    end
+
+    def test_intersection_sample_graph_and_itself_5_times_and_empty_graph
+        g = @@sample_graph
+        empty = Graph.new
+        empty2 = empty.clone
+
+        assert_equal(empty2, Graph::intersection(g, g, empty, g, g, g))
+    end
+
+    def test_intersection_one_node_graph_and_one_other_node_graph
+        g = Graph.new([{'label'=>'foo'}])
+        h = Graph.new([{'label'=>'bar'}])
+        empty = Graph.new
+
+        assert_equal(empty, Graph::intersection(g, h))
+    end
+
+    def test_intersection_sample_graph_and_no_graph
+        g = @@sample_graph
+
+        assert_equal(nil, Graph::intersection(g, 2))
+        assert_equal(nil, Graph::intersection(g, true))
+        assert_equal(nil, Graph::intersection(g, false))
+        assert_equal(nil, Graph::intersection(g, ['foo', 'bar']))
+        assert_equal(nil, Graph::intersection(g, 'foo'))
+    end
+
+    def test_intersection_2_graphs_same_nodes_different_fields
+        g1 = @@sample_graph.clone
+        g2 = @@sample_graph_1.clone
+        empty = Graph.new
+
+        assert_equal(empty, Graph::intersection(g1, g2))
+        # test for side effects
+        assert_equal(@@sample_graph, g1)
+        assert_equal(@@sample_graph_1, g2)
+    end
+
+    def test_intersection_2_graphs_same_nodes_different_fields_same_fields_option
+        g1 = @@sample_graph.clone
+        g2 = @@sample_graph_1.clone
+        
+        intersec = Graph.new(
+            [
+                {'label'=>'foo'},
+                {'label'=>'bar'},
+                {'label'=>'chuck'}
+            ],
+            [
+                {'node1'=>'foo', 'node2'=>'bar'},
+                {'node1'=>'bar', 'node2'=>'foo'},
+                {'node1'=>'foo', 'node2'=>'chuck'}
+            ]
+        )
+
+        assert_equal(intersec, Graph::intersection(g1, g2, :same_fields => true))
+        # test for side effects
+        assert_equal(@@sample_graph, g1)
+        assert_equal(@@sample_graph_1, g2)
+    end
+
+
+    # == Graph#new == #
+
     def test_new_empty_graph
         g = Graph.new
 
@@ -41,6 +140,20 @@ class Graph_test < Test::Unit::TestCase
         assert_equal([], g.edges)
     end
 
+    # == Graph#clone == #
+
+    def test_empty_graph_clone
+        g = Graph.new
+        h = g.clone
+
+        assert_equal(g, h)
+
+        h.nodes.push({})
+
+        assert_equal(0, g.nodes.length)
+        assert_not_equal(g, h)
+    end
+
     # == Graph#== == #
 
     def test_equal_graphs

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphs
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: x86-linux
 authors: