graphs 0.1.0-x86-linux

data/lib/graph.rb

@@ -0,0 +1,81 @@
+# -*- coding: UTF-8 -*-
+
+require 'yaml'
+
+class Graph
+
+    class NodeArray < Array
+
+        def initialize(*args)
+            super(*args)
+            @defaults = {}
+        end
+
+        def set_default(dict)
+            @defaults.update(dict)
+            self.map! { |e| e.update(@defaults) }
+        end
+
+        def push(o)
+            if (!o.is_a?(Hash))
+                raise TypeError.new "#{o.inspect} is not an Hash!"
+            end
+            o2 = o.clone
+            o2.update(@defaults)
+            super
+        end
+    end
+
+    class EdgeArray < NodeArray
+    end
+
+    attr_accessor :nodes, :edges
+
+    def initialize(nodes=nil, edges=nil)
+        @nodes = NodeArray.new(nodes || [])
+        @edges = EdgeArray.new(edges || [])
+    end
+
+    def ==(other)
+        if (!other.is_a?(Graph))
+            return false
+        end
+        (self.nodes === other.nodes) && (self.edges == other.edges)
+    end
+
+    def &(other)
+        if (!other.is_a?(Graph))
+            return nil
+        end
+
+        nodes = @nodes & other.nodes
+        edges = @edges & other.edges
+
+        Graph.new(nodes, edges)
+    end
+
+    def write(filename, opts=nil)
+
+        has_ext = filename.split('.')
+
+        if ((has_ext.length == 1) || (has_ext[-1] == 'yml'))
+            # YAML (default)
+            nodes = self.nodes.to_a
+            edges = self.edges.to_a
+
+            data = {'nodes'=>nodes, 'edges'=>edges}.to_yaml
+            f = open(filename+'.yml', 'w')
+            f.write(data)
+            f.close
+        else
+            ext = has_ext[-1]
+
+            m = (self.methods - Object.methods).map {|e| e.to_s}
+
+            if (m.include? '_write_'+ext.downcase)
+                self.send('_write_'+ext.downcase, filename, opts)
+            end
+        end
+
+    end
+end

data/lib/graphs/gdf.rb

@@ -0,0 +1,182 @@
+# -*- coding: UTF-8 -*-
+
+require_relative '../graph'
+
+class Graph
+    def to_gdf(opts=nil)
+        GDF::unparse(self, opts)
+    end
+
+    def _write_gdf(filename, opts=nil)
+        gdf = GDF::unparse(self, opts)
+        f = File.open(filename, 'w')
+        f.write(gdf)
+        f.close
+    end
+end
+
+module GDF
+
+    def self.load(filename)
+        self.parse(File.read(filename))
+    end
+
+    def self.parse(content)
+
+        if (content.nil? || content.length == 0)
+            return Graph.new([],[])
+        end
+
+        content = content.split("\n")
+
+        # lines index of 'nodedef>' and 'edgedef>'
+        nodes_def_index = -1
+        edges_def_index = -1
+
+        content.each_with_index {|l,i|
+            if l.start_with? 'nodedef>'
+                nodes_def_index = i
+            elsif l.start_with? 'edgedef>'
+                edges_def_index = i
+            end
+
+            if ((nodes_def_index >= 0) && (edges_def_index >= 0))
+                break
+            end
+        }
+
+        # no edges
+        if (edges_def_index == -1)
+            edges = []
+            edges_def_index = content.length
+        else
+            edges = content[edges_def_index+1..content.length]
+        end
+
+        fields_split = /[\t ]*,[\t ]*/
+
+        # only nodes lines
+        nodes = content[nodes_def_index+1..[edges_def_index-1, content.length].min] || []
+
+        nodes_def = content[nodes_def_index]
+        nodes_def = nodes_def['nodedef>'.length..nodes_def.length].strip.split(fields_split)
+        nodes_def.each_index {|i|
+            nodes_def[i] = read_def(nodes_def[i])
+        }
+
+        nodes.each_with_index {|n,i|
+            n2 = {}
+            n = n.split(fields_split)
+            n.zip(nodes_def).each {|val,label_type|
+                label, type = label_type
+                n2[label] = parse_field(val, type)
+            }
+            nodes[i] = n2
+        }
+
+        if (edges === [])
+            return Graph.new(nodes)
+        end
+
+        # only edges lines
+        edges_def = content[edges_def_index]
+        edges_def = edges_def['edgedef>'.length..edges_def.length].strip.split(fields_split)
+        edges_def.each_index {|i|
+            edges_def[i] = read_def(edges_def[i])
+        }
+
+        edges.each_with_index {|e,i|
+            e2 = {}
+            e = e.split(fields_split)
+
+            e.zip(edges_def).each {|val,label_type|
+                label, type = label_type
+                e2[label] = parse_field(val, type)
+            }
+            edges[i] = e2
+        }
+
+        Graph.new(nodes, edges)
+    end
+
+    def self.unparse(graph, opts=nil)
+
+        # nodes
+        gdf_s = 'nodedef>'
+
+        if (graph.nodes.length == 0)
+            return gdf_s
+        end
+
+        keys = graph.nodes[0].keys
+        nodedef = keys.map { |k| [k, self.get_type(graph.nodes[0][k], opts)] }
+
+        gdf_s += (nodedef.map {|nd| nd.join(' ')}).join(',') + "\n"
+
+        graph.nodes.each { |n|
+            gdf_s += n.values.join(',') + "\n"
+        }
+
+        # edges
+        gdf_s += 'edgedef>'
+
+        if (graph.edges.length == 0)
+            return gdf_s
+        end
+
+        keys = graph.edges[0].keys
+        edgedef = keys.map { |k| [k, self.get_type(graph.edges[0][k], opts)] }
+
+        gdf_s += (edgedef.map {|ed| ed.join(' ')}).join(',') + "\n"
+
+        graph.edges.each { |e|
+            gdf_s += e.values.join(',') + "\n"
+        }
+
+        gdf_s
+    end
+
+    private
+
+    # read the value of a node|edge field, and return the value's type (String)
+    def self.get_type(v, opts=nil)
+        opts = opts || {}
+
+        if v.is_a?(Fixnum)
+            return 'INT'
+        elsif v.is_a?(Bignum)
+            return opts[:gephi] ? 'INT' : 'BIGINT'
+        elsif v.is_a?(TrueClass) || v.is_a?(FalseClass)
+            return 'BOOLEAN'
+        elsif v.is_a?(Float)
+            return 'FLOAT'
+        else
+            return 'VARCHAR'
+        end
+    end
+
+    # read a (node|edge)def, and return ['label', 'type of value']
+    def self.read_def(s)
+        *label, value_type = s.split /\s+/
+            if /((tiny|small|medium|big)?int|integer)/i.match(value_type)
+                value_type = 'int'
+            elsif /(float|real|double)/i.match(value_type)
+                value_type = 'float'
+            elsif (value_type.downcase === 'boolean')
+                value_type = 'boolean'
+            end
+
+        [label.join(' '), value_type]
+    end
+
+    # read a field and return its value
+    def self.parse_field(f, value_type)
+        case value_type
+        when 'int'     then f.to_i
+        when 'float'   then f.to_f
+        when 'boolean' then !(/(null|false)/i =~ f)
+        else f
+        end
+    end
+
+end

data/tests/tests_gdf.rb

@@ -0,0 +1,220 @@
+#! /usr/bin/ruby1.9.1
+
+require '../lib/graph'
+require '../lib/graphes/gdf'
+require 'test/unit'
+
+module Utils
+    def self.get_sample_graph
+        @@sample_graph_1
+    end
+
+    @@sample_graph_1  = "nodedef>label VARCHAR,num INT,biglabel VARCHAR\n"
+    @@sample_graph_1 += "toto,14,TOTO\nlala,5,LALA\ntiti,988,TITI\n"
+    @@sample_graph_1 += "edgedef>node1 VARCHAR,node2 VARCHAR,directed BOOLEAN\n"
+    @@sample_graph_1 += "toto,lala,true\nlala,titi,true\n"
+    @@sample_graph_1 += "titi,lala,false\ntiti,toto,true\n"
+end
+
+class GDF_Graph_test < Test::Unit::TestCase
+
+    # == Graph#to_gdf == #
+
+    def test_empty_graph_to_gdf
+        g = Graph.new
+        empty_gdf = "nodedef>"
+
+        assert_equal(empty_gdf, g.to_gdf)
+    end
+
+    def test_sample_graph_to_gdf
+        gdf = Utils::get_sample_graph
+        g = GDF::parse(gdf)
+        assert_equal(gdf, g.to_gdf)
+    end
+
+    # == Graph#write('….gdf') == #
+
+    def test_empty_graph_write_gdf
+        g = Graph.new
+        g.write('/tmp/_graph_test.gdf')
+        g2 = GDF.load('/tmp/_graph_test.gdf')
+        assert_equal(g, g2)
+    end
+
+    def setup
+        if File.exists? '/tmp/_graph_test.gdf'
+            File.delete '/tmp/_graph_test.gdf'
+        end
+    end
+end
+
+class GDF_test < Test::Unit::TestCase
+
+    # == GDF::parse == #
+
+    def test_parse_empty_graph
+        g = GDF::parse('')
+
+        assert_equal([], g.nodes)
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_empty_graph_with_nodedef
+
+        s = "nodedef>label VARCHAR\n" 
+
+        g = GDF::parse(s)
+
+        assert_equal([], g.nodes)
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_empty_graph_with_nodedef_and_edgedef
+        s = "nodedef>label VARCHAR\nedgedef>node1 VARCHAR,node2 VARCHAR\n"
+        g = GDF::parse(s)
+
+        assert_equal([], g.nodes)
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_string_field
+        s = "nodedef>label VARCHAR\nfoo\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('foo', g.nodes[0]['label'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_tinyint_field
+        s = "nodedef>num TINYINT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_smallint_field
+        s = "nodedef>num SMALLINT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_int_field
+        s = "nodedef>num INT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_negative_int_field
+        s = "nodedef>num INT\n-1337\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(-1337, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_bigint_field
+        s = "nodedef>num BIGINT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_float_field
+        s = "nodedef>num FLOAT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3.0, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_double_field
+        s = "nodedef>num FLOAT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3.0, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_real_field
+        s = "nodedef>num FLOAT\n3\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(3.0, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_negative_real_field
+        s = "nodedef>num FLOAT\n-42.14\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal(-42.14, g.nodes[0]['num'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_one_node_no_edge_unknow_field_type
+        s = "nodedef>foo BAR\nfoobar"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('foobar', g.nodes[0]['foo'])
+        assert_equal([], g.edges)
+    end
+
+    def test_parse_sample_graph
+        g = GDF::parse(Utils::get_sample_graph)
+
+        assert_equal(3, g.nodes.length)
+        assert_equal(4, g.edges.length)
+
+        assert_equal('toto', g.nodes[0]['label'])
+        assert_equal('TOTO', g.nodes[0]['biglabel'])
+        assert_equal(988, g.nodes[2]['num'])
+
+        assert_equal('toto', g.edges[0]['node1'])
+        assert_equal('lala', g.edges[0]['node2'])
+        assert_equal(false, g.edges[2]['directed'])
+
+    end
+
+    # == GDF::unparse == #
+
+    def test_unparse_empty_graph
+        g = Graph.new
+
+        s = GDF::unparse(g)
+
+        assert_equal("nodedef>", s)
+    end
+
+    def test_unparse_sample_graph
+        g1 = GDF::parse(Utils::get_sample_graph)
+        g2 = GDF::parse(GDF::unparse(g1))
+
+        assert_equal(g1, g2)
+    end
+
+    def test_unparse_big_int_gephi
+        g = Graph.new([{'n'=>9999999999999999}])
+        gdf = GDF::unparse(g, {:gephi=>true})
+
+        assert_equal("nodedef>n INT\n9999999999999999\nedgedef>", gdf)
+
+    end
+end

data/tests/tests_gexf.rb

@@ -0,0 +1,5 @@
+#! /usr/bin/ruby1.9.1
+# -*- coding: UTF-8 -*-
+
+require 'test/unit'
+require '../lib/graphes/gexf'

data/tests/tests_graph.rb

@@ -0,0 +1,174 @@
+#! /usr/bin/ruby1.9.1
+# -*- coding: UTF-8 -*-
+
+require 'test/unit'
+require 'yaml'
+require_relative '../lib/graph'
+
+class Graph_test < Test::Unit::TestCase
+
+    @@sample_graph = Graph.new(
+        [
+            {'label'=>'foo', 'id'=>2},
+            {'label'=>'bar', 'id'=>1},
+            {'label'=>'chuck', 'id'=>3}
+        ],
+        [
+            {'node1'=>'foo', 'node2'=>'bar'},
+            {'node1'=>'bar', 'node2'=>'foo'},
+            {'node1'=>'bar', 'node2'=>'chuck'},
+            {'node1'=>'foo', 'node2'=>'chuck'}
+        ]
+    )
+
+    def test_new_empty_graph
+        g = Graph.new
+
+        assert_equal([], g.nodes)
+        assert_equal([], g.edges)
+    end
+
+    # == Graph#== == #
+
+    def test_equal_graphs
+        g1 = @@sample_graph
+        g2 = @@sample_graph.clone()
+
+        assert_equal(true, g1==g2)
+    end
+
+    # == Graph::NodeArray#set_default == #
+
+    def test_nodearray_set_default_unexisting_property
+        g = Graph.new([{'name'=>'foo'}, {'name'=>'bar'}])
+        g.nodes.set_default 'age' => 21
+
+        assert_equal(21, g.nodes[0]['age'])
+        assert_equal(21, g.nodes[1]['age'])
+    end
+
+    def test_nodearray_set_default_existing_property
+        g = Graph.new([{'name'=>'foo', 'age'=>42}, {'name'=>'bar'}])
+        g.nodes.set_default 'age' => 21
+
+        assert_equal(21, g.nodes[0]['age'])
+        assert_equal(21, g.nodes[1]['age'])
+    end
+
+    def test_nodearray_set_default_unexisting_property_before_push
+        g = Graph.new([{'name'=>'foo'}])
+        g.nodes.set_default 'city' => 'Paris'
+        g.nodes.push({'name' => 'bar'})
+
+        assert_equal('Paris', g.nodes[0]['city'])
+        assert_equal('Paris', g.nodes[0]['city'])
+    end
+
+    def test_nodearray_set_default_existing_property_before_push
+        g = Graph.new([{'name'=>'foo', 'city'=>'London'}])
+        g.nodes.set_default 'city' => 'Paris'
+        g.nodes.push({'name' => 'bar'})
+
+        assert_equal('Paris', g.nodes[0]['city'])
+        assert_equal('Paris', g.nodes[0]['city'])
+    end
+
+    # == Graph::edgeArray#set_default == #
+
+    def test_edgearray_set_default_unexisting_property
+        g = Graph.new([],[{'node1'=>'foo', 'node2'=>'bar'}])
+        g.edges.set_default 'directed' => true
+
+        assert_equal(true, g.edges[0]['directed'])
+    end
+
+    def test_edgearray_set_default_existing_property
+        g = Graph.new([],
+                           [{'node1'=>'foo', 'node2'=>'bar', 'directed'=>true},
+                            {'node1'=>'bar', 'node2'=>'foo'}])
+        g.edges.set_default 'directed' => false
+
+        assert_equal(false, g.edges[0]['directed'])
+        assert_equal(false, g.edges[1]['directed'])
+    end
+
+    def test_edgearray_set_default_unexisting_property_before_push
+        g = Graph.new([], [{'node1'=>'foo', 'node2'=>'bar'}])
+        g.edges.set_default 'directed' => true
+        g.edges.push({'node1' => 'bar', 'node2'=>'foo'})
+
+        assert_equal(true, g.edges[0]['directed'])
+        assert_equal(true, g.edges[0]['directed'])
+    end
+
+    def test_edgearray_set_default_existing_property_before_push
+        g = Graph.new([],
+                           [{'node1'=>'foo', 'node2'=>'bar', 'directed'=>true}])
+        g.edges.set_default 'node2' => 'foo'
+        g.edges.push({'node1' => 'bar', 'node2' => 'foo'})
+
+        assert_equal('foo', g.edges[0]['node2'])
+        assert_equal('foo', g.edges[0]['node2'])
+    end
+
+    # == Graph#& == #
+
+    def test_empty_graph_AND_empty_graph
+        g1 = Graph.new
+        g2 = Graph.new
+
+        assert_equal(g1, g1 & g2)
+    end
+
+    def test_one_node_graph_AND_empty_graph
+        g = Graph.new([{'label'=>'foo'}])
+        empty = Graph.new
+
+        assert_equal(empty, g & empty)
+    end
+
+    def test_empty_graph_AND_one_node_graph
+        g = Graph.new([{'label'=>'foo'}])
+        empty = Graph.new
+
+        assert_equal(empty, empty & g)
+    end
+
+    def test_sample_graph_AND_itself
+        g = @@sample_graph
+
+        assert_equal(g, g & g)
+    end
+
+    def test_one_node_graph_AND_one_other_node_graph
+        g = Graph.new([{'label'=>'foo'}])
+        h = Graph.new([{'label'=>'bar'}])
+        empty = Graph.new
+
+        assert_equal(empty, g & h)
+    end
+
+    def test_sample_graph_AND_no_graph
+        g = @@sample_graph
+
+        assert_equal(nil, g & 2)
+        assert_equal(nil, g & true)
+        assert_equal(nil, g & false)
+        assert_equal(nil, g & ['foo', 'bar'])
+        assert_equal(nil, g & {'foo'=>'bar'})
+        assert_equal(nil, g & 'foo')
+    end
+
+    # == Graph#write == #
+
+    def test_graph_write_no_ext
+        g = @@sample_graph
+        f = '/tmp/_graph_test'
+        g.write(f)
+        assert_equal(true, File.exists?(f))
+        
+        dict = YAML.load(File.open(f))
+        assert_equal(g.nodes, dict['nodes'])
+        assert_equal(g.edges, dict['edges'])
+    end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: graphs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: x86-linux
+authors:
+- Baptiste Fontaine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-02 00:00:00.000000000 Z
+dependencies: []
+description: Provide functions to (un)parse GDF files and generate graphs
+email: batifon@yahoo.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/graph.rb
+- lib/graphs/gdf.rb
+- tests/tests_gexf.rb
+- tests/tests_graph.rb
+- tests/tests_gdf.rb
+homepage: https://github.com/bfontaine/Graph.rb
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Utilities to manipulate graph files
+test_files:
+- tests/tests_gexf.rb
+- tests/tests_graph.rb
+- tests/tests_gdf.rb