graphs 0.2.0

data/lib/graphs/gdf.rb

@@ -0,0 +1,225 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+require 'csv'
+require_relative '../graph'
+
+class Graph
+    # Returns a GDF version of the current graph
+    # @param opts [Hash] A customizable set of options
+    # @return [String]
+    # @see GDF.unparse
+    def to_gdf(opts=nil)
+        GDF::unparse(self, opts)
+    end
+
+    # Write the current graph into a GDF file. This method is used internally,
+    # use Graph#write instead.
+    # @param filename [String] a valid filename
+    # @return []
+    # @see GDF.unparse
+    def write_gdf(filename, opts=nil)
+        gdf = GDF::unparse(self, opts)
+        f = File.open(filename, 'w')
+        f.write(gdf)
+        f.close
+    end
+end
+
+# GDF-related functions
+# see http://guess.wikispot.org/The_GUESS_.gdf_format
+module GDF
+
+    # Node fields definition
+    NODEDEF = 'nodedef>'
+
+    # Edge fields definition
+    EDGEDEF = 'edgedef>'
+
+    # Non-string predefined node properties
+    PREDEFINED_NODE_PROPS = {
+      'x' => 'float',
+      'y' => 'float',
+      'visible' => 'boolean',
+      'fixed' => 'boolean',
+      'style' => 'int',
+      'width' => 'float',
+      'height' => 'float'
+    }
+
+    # Non-string predefined edge properties
+    PREDEFINED_EDGE_PROPS = {
+      'visible' => 'boolean',
+      'weight' => 'float',
+      'width' => 'float',
+      'directed' => 'boolean',
+      'labelvisible' => 'boolean'
+    }
+
+    # Loads a GDF file and return a new Graph object
+    # @param filename [String] a valid filename
+    # @see GDF.parse
+    def self.load(filename)
+        self.parse(File.read(filename))
+    end
+
+    # Parse some GDF text and return a new Graph object
+    # @param content [String] a valid GDF String
+    # @see GDF.load
+    # @see GDF.unparse
+    def self.parse(content)
+
+        if (content.nil? || content.length == 0)
+            return Graph.new([],[])
+        end
+
+        fields_split = /[\t ]*,[\t ]*/
+
+        nodedef_len, edgedef_len = NODEDEF.length, EDGEDEF.length
+
+        current_def = nil
+
+        nodes, edges = [], []
+        current_set = nil
+
+        content.each_line do |line|
+          line.strip!
+          is_nodedef = line.start_with? NODEDEF
+          is_edgedef = !is_nodedef && line.start_with?(EDGEDEF)
+
+          if is_nodedef || is_edgedef
+            line.slice!(0, is_nodedef ? nodedef_len : edgedef_len)
+            line.strip!
+            defaults = is_nodedef ? PREDEFINED_NODE_PROPS : PREDEFINED_EDGE_PROPS
+            current_def = line.split(fields_split).map do |l|
+              read_def(l, defaults)
+            end
+
+            current_set = is_nodedef ? nodes : edges
+          else
+            el = {}
+            fields = line.parse_csv || [nil]
+            fields.zip(current_def).each do |val,label_type|
+              label, type, default = label_type
+              el[label] = parse_field(val, type, default)
+            end
+            current_set << el
+          end
+        end
+
+        Graph.new(nodes, edges)
+    end
+
+    # Return a GDF String which describe the given Graph
+    # @param graph [Graph]
+    # @param opts [Hash] A customizable set of options
+    # @return [String]
+    # @see Graph#write
+    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 do |n|
+            gdf_s += n.values.to_csv
+        end
+
+        # edges
+        gdf_s += EDGEDEF
+
+        return gdf_s if graph.edges.empty?
+
+        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 do |e|
+            gdf_s += e.values.to_csv
+        end
+
+        gdf_s
+    end
+
+    private
+
+    # Read the value of a node/edge field, and return the value's
+    # type (String)
+    # @param v
+    # @param opts [Hash]
+    # @return [String]
+    def self.get_type(v, opts=nil)
+        opts = opts || {}
+
+        if v.is_a?(Fixnum) || v.is_a?(Bignum)
+            if opts[:gephi] || v <= 2147483647
+              return 'INT'
+            else
+              return 'BIGINT'
+            end
+        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 a list where the first element is the
+    # label of the field, the second its type, and the third and last one its
+    # default value
+    # @param s
+    # @param defaults
+    def self.read_def(s, defaults={})
+        label, *params = s.split(/\s+/)
+        default = nil
+
+        if params.empty?
+          value_type = defaults[label.downcase] || 'VARCHAR'
+        else
+          value_type = params.shift
+
+          if params.shift == 'default'
+            default = parse_field(params.shift, value_type.downcase)
+          end
+
+          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
+        end
+
+        [label, value_type, default]
+    end
+
+    # read a field and return its value
+    # @param f
+    # @param value_type [String]
+    # @param default
+    def self.parse_field(f, value_type, default=nil)
+        case value_type
+        when 'int'     then (f || default).to_i
+        when 'float'   then (f || default).to_f
+        when 'boolean' then
+          if f.nil?
+            default.nil? ? false : default
+          else
+            /^(?:null|false|)$/i !~ f
+          end
+        else f || default
+        end
+    end
+
+end

data/lib/graphs/json.rb

@@ -0,0 +1,71 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+require 'json'
+require_relative '../graph'
+
+class Graph
+    # Returns a JSON version of the current graph
+    # @param opts [Hash] A customizable set of options
+    # @return [String]
+    # @see JSONGraph.unparse
+    def to_json(opts=nil)
+        JSONGraph::unparse(self, opts)
+    end
+
+    # Write the current graph into a JSON file. This method is used internally,
+    # use Graph#write instead.
+    # @param filename [String] a valid filename
+    # @return []
+    # @see JSON.unparse
+    def write_json(filename, opts=nil)
+        json = JSONGraph::unparse(self, opts)
+        f = File.open(filename, 'w')
+        f.write(json)
+        f.close
+    end
+end
+
+# JSON-related functions
+module JSONGraph
+
+    # Loads a JSON file and return a new Graph object
+    # @param filename [String] a valid filename
+    # @return [Graph]
+    # @see JSONGraph.parse
+    def self.load(filename)
+        self.parse(File.read(filename))
+    end
+
+    # Parse some JSON text and return a new Graph object
+    # @param content [String] a valid GDF String
+    # @return [Graph]
+    # @see JSONGraph.load
+    # @see JSONGraph.unparse
+    def self.parse(content)
+
+        if (content.nil? || content.length == 0)
+            return Graph.new([],[])
+        end
+
+        content = JSON.parse content
+
+        nodes = content['nodes']
+        edges = content['edges']
+
+        Graph.new(nodes, edges)
+    end
+
+    # Return a JSON String which describe the given Graph
+    # @param graph [Graph]
+    # @param opts [Hash] A customizable set of options
+    # @return [String]
+    # @see Graph#write
+    def self.unparse(graph, opts=nil)
+
+        nodes = graph.nodes.map { |n| n.to_hash }
+        edges = graph.edges.map { |e| e.to_hash }
+
+        JSON.dump({ 'nodes' => nodes, 'edges' => edges })
+    end
+end

data/tests/edge_tests.rb

@@ -0,0 +1,92 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+class Edge_test < Test::Unit::TestCase
+    
+    def setup
+        @@empty = Graph::Node.new
+        @@alice = Graph::Node.new('label' => 'Alice')
+    
+        # Alice ----> Bob
+        #   ↑          ↑
+        #   |          |
+        # Oscar -------'
+        @@sample_graph = Graph.new(
+            [
+                { 'label' => 'Alice' },
+                { 'label' => 'Bob'   },
+                { 'label' => 'Oscar' }
+            ],
+            [
+                { 'node1' => 'Alice', 'node2' => 'Bob' },
+                { :node1  => 'Oscar', 'node2' => 'Alice'},
+                { 'node1' => 'Oscar', :node2  => 'Bob'}
+            ]
+        )
+    
+    end
+
+    def test_edge_node1_attr
+        assert_equal('Alice', @@sample_graph.edges[0].node1)
+        assert_equal('Oscar', @@sample_graph.edges[1].node1)
+    end
+
+    def test_edge_node2_attr
+        assert_equal('Alice', @@sample_graph.edges[1].node2)
+        assert_equal('Bob', @@sample_graph.edges[2].node2)
+    end
+
+    def test_edge_update
+
+        e = Graph::Edge.new
+
+        assert_equal(true, e.update({}).is_a?(Graph::Edge))
+    end
+
+    def test_edge_init_with_another_edge
+
+        e = Graph::Edge.new({ :foo => 'bar' })
+
+        assert_equal( e, Graph::Edge.new(e) )
+
+    end
+
+end
+
+class EdgeArray_test < Test::Unit::TestCase
+
+    def test_edgearray_push_edge
+
+        e = Graph::Edge.new({ :foo => 42 })
+        ea = Graph::EdgeArray.new([])
+
+        ea.push(e)
+
+        assert_equal(e, ea[0])
+
+    end
+
+    def test_edgearray_push_hash
+
+        e = { :foo => 42 }
+        ea = Graph::EdgeArray.new([])
+
+        ea.push(e)
+
+        assert_equal(Graph::Edge.new(e), ea[0])
+
+    end
+
+    def test_edgearray_push_no_edge_nor_hash
+
+        ea = Graph::EdgeArray.new([])
+
+        assert_raise(TypeError) do
+
+            ea.push(42)
+
+        end
+
+    end
+
+end

data/tests/gdf_tests.rb

@@ -0,0 +1,377 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+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
+
+        f = Tempfile.new([ 'foo', '.gdf' ])
+        f.close
+
+        g.write(f.path)
+        g2 = GDF.load(f.path)
+
+        assert_equal(g, g2)
+        f.unlink
+    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_space_after_nodedef
+        g = GDF::parse("nodedef> foo VARCHAR\nbar")
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('bar', g.nodes[0]['foo'])
+    end
+
+    def test_parse_quoted_value
+      code = <<EOC
+nodedef>label VARCHAR
+"foo"
+EOC
+
+      g = GDF::parse(code)
+      assert_equal(1, g.nodes.length)
+      assert_equal('foo', g.nodes[0].attrs['label'])
+    end
+
+    def test_parse_quoted_value_with_quote
+      code = <<EOC
+nodedef>label VARCHAR
+"fo""o"
+EOC
+
+      g = GDF::parse(code)
+      assert_equal(1, g.nodes.length)
+      assert_equal('fo"o', g.nodes[0].attrs['label'])
+    end
+
+    def test_parse_value_with_comma
+      code = <<EOC
+nodedef>label VARCHAR,num INT
+"foo,bar",42
+EOC
+
+      g = GDF::parse(code)
+      assert_equal(1, g.nodes.length)
+      assert_equal('foo,bar', g.nodes[0].attrs['label'])
+    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_one_node_no_type
+        s = "nodedef>foo\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_one_node_builtin_visible_prop_no_type
+        s = "nodedef>visible,foo VARCHAR\n,bar\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('bar', g.nodes[0]['foo'])
+        assert_equal(false, g.nodes[0]['visible'])
+    end
+
+    def test_parse_one_node_builtin_visible_prop_with_type
+        s = "nodedef>visible BOOLEAN,foo VARCHAR\n,bar\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('bar', g.nodes[0]['foo'])
+        assert_equal(false, g.nodes[0]['visible'])
+    end
+
+    def test_parse_one_node_truthy_boolean_value
+        s = "nodedef>xyz BOOLEAN,foo VARCHAR\nxfalse,bar\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('bar', g.nodes[0]['foo'])
+        assert_equal(true, g.nodes[0]['xyz'])
+    end
+
+    def test_parse_one_node_null_boolean_value
+        s = "nodedef>xyz BOOLEAN,foo VARCHAR\nnull,bar\n"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('bar', g.nodes[0]['foo'])
+        assert_equal(false, g.nodes[0]['xyz'])
+    end
+
+    def test_parse_nodes_only_one_empty_boolean_value
+        s = "nodedef>xyz BOOLEAN\n\n\n"
+        g = GDF::parse(s)
+
+        assert_equal(2, g.nodes.length)
+        assert_equal(false, g.nodes[0]['xyz'])
+        assert_equal(false, g.nodes[1]['xyz'])
+    end
+
+    def test_parse_nodes_default_int_value
+        s = "nodedef>xyz INT default 42,foo VARCHAR\n,bar\n12,foo"
+        g = GDF::parse(s)
+
+        assert_equal(2, g.nodes.length)
+        assert_equal(42, g.nodes[0]['xyz'])
+        assert_equal(12, g.nodes[1]['xyz'])
+    end
+
+    def test_parse_nodes_default_boolean_value_true
+        s = "nodedef>xyz BOOLEAN default true,foo VARCHAR\n,bar\nfalse,foo"
+        g = GDF::parse(s)
+
+        assert_equal(2, g.nodes.length)
+        assert_equal(true, g.nodes[0]['xyz'])
+        assert_equal(false, g.nodes[1]['xyz'])
+    end
+
+    def test_parse_nodes_default_boolean_value_false
+        s = "nodedef>xyz BOOLEAN default false,foo VARCHAR\n,bar\ntrue,foo"
+        g = GDF::parse(s)
+
+        assert_equal(2, g.nodes.length)
+        assert_equal(false, g.nodes[0]['xyz'])
+        assert_equal(true, g.nodes[1]['xyz'])
+    end
+
+    def test_parse_one_edge_no_type
+        s = "nodedef>label VARCHAR\nfoobar\nedgedef>node1,node2\nfoobar,foobar"
+        g = GDF::parse(s)
+
+        assert_equal(1, g.nodes.length)
+        assert_equal('foobar', g.nodes[0]['label'])
+        assert_equal('foobar', g.edges[0]['node1'])
+        assert_equal('foobar', g.edges[0]['node2'])
+    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
+        n = 2**40
+        g = Graph.new([{'n'=>n}])
+        gdf = GDF::unparse(g)
+
+        assert_equal("nodedef>n BIGINT\n#{n}\nedgedef>", gdf)
+    end
+
+    def test_unparse_big_int_gephi
+        n = 2**40
+        g = Graph.new([{'n'=>n}])
+        gdf = GDF::unparse(g, {:gephi=>true})
+
+        assert_equal("nodedef>n INT\n#{n}\nedgedef>", gdf)
+    end
+
+    def test_unparse_float_field
+        g = Graph.new([{ 'n' => 3.14 }])
+        gdf = GDF::unparse(g)
+
+        assert_equal("nodedef>n FLOAT\n3.14\nedgedef>", gdf)
+    end
+
+    def test_unparse_value_with_quote
+      g = Graph.new([{'n' => 'foo"bar'}])
+      gdf = GDF::unparse(g)
+
+      assert_equal("nodedef>n VARCHAR\n\"foo\"\"bar\"\nedgedef>", gdf)
+    end
+
+    def test_unparse_value_with_comma
+      g = Graph.new([{'n' => 'foo,bar'}])
+      gdf = GDF::unparse(g)
+
+      assert_equal("nodedef>n VARCHAR\n\"foo,bar\"\nedgedef>", gdf)
+    end
+end