ruby-graphviz 0.9.16 → 0.9.17

data/lib/graphviz.rb

@@ -25,6 +25,7 @@ require 'graphviz/node'
 require 'graphviz/edge'
 require 'graphviz/attrs'
 require 'graphviz/constants'
+require 'graphviz/elements'
 
 require 'graphviz/dot2ruby'
 require 'graphviz/types'
@@ -93,7 +94,8 @@ class GraphViz
   #
   def add_node( xNodeName, hOpts = {} )
     @hoNodes[xNodeName] = GraphViz::Node::new( xNodeName, self )
-   
+    @hoNodes[xNodeName].index = @elements_order.size_of( "node" )
+    
     unless hOpts.keys.include?(:label) or hOpts.keys.include?("label")
       hOpts[:label] = xNodeName
     end
@@ -122,12 +124,24 @@ class GraphViz
     return node
   end
   
+  #
+  # Return the node object for the given index
+  #
+  def get_node_at_index( index )
+    element = @elements_order[index, "node"]
+    (element.nil?) ? nil : element["value"]
+  end
+  
   #
   # Allow you to traverse nodes
   #
   def each_node( &block )
-    @hoNodes.each do |name, node|
-      yield( name, node )
+    if block_given?
+      @hoNodes.each do |name, node|
+        yield( name, node )
+      end
+    else
+      return( @hoNodes )
     end
   end
   
@@ -159,6 +173,7 @@ class GraphViz
         end
       else
         oEdge = GraphViz::Edge::new( oNodeOne, oNodeTwo, self )
+        oEdge.index = @elements_order.size_of( "edge" )
         
         hOpts.each do |xKey, xValue|
           oEdge[xKey.to_s] = xValue
@@ -179,8 +194,12 @@ class GraphViz
   # Allow you to traverse edges
   #
   def each_edge( &block )
-    @loEdges.each do |edge|
-      yield(edge)
+    if block_given?
+      @loEdges.each do |edge|
+        yield(edge)
+      end
+    else
+      return @loEdges
     end
   end
   
@@ -191,6 +210,14 @@ class GraphViz
     @loEdges.size
   end
   
+  #
+  # Return the edge object for the given index
+  #
+  def get_edge_at_index( index )
+    element = @elements_order[index, "edge"]
+    (element.nil?) ? nil : element["value"]
+  end
+  
   # 
   # Create a new graph
   # 
@@ -241,11 +268,21 @@ class GraphViz
   # Allow you to traverse graphs
   #
   def each_graph( &block )
-    @hoGraphs.each do |name, graph|
-      yield( name, graph )
+    if block_given?
+      @hoGraphs.each do |name, graph|
+        yield( name, graph )
+      end
+    else
+      return @hoGraphs
     end
   end
   
+  #
+  # Return the graph type (graph digraph)
+  def type
+    @oGraphType
+  end
+  
   #
   # Get the number of graphs
   #
@@ -669,7 +706,7 @@ class GraphViz
     @output   = {}
     @nothugly = false
     
-    @elements_order = Array::new()
+    @elements_order = GraphViz::Elements::new()
 
     @oParentGraph = nil
     @oGraphType   = "digraph"

data/lib/graphviz/constants.rb

@@ -40,7 +40,7 @@
 #   C => cluster
 #
 module Constants
-  RGV_VERSION = "0.9.16"
+  RGV_VERSION = "0.9.17"
   
   ## Const: Output formats
   FORMATS = [
@@ -96,7 +96,8 @@ module Constants
     "neato",
     "twopi",
     "fdp",
-    "circo"
+    "circo",
+    "sfdp"
   ]
 
   ## Const: graphs type
@@ -115,11 +116,11 @@ module Constants
   
   # E, N, G, S and C represent edges, nodes, the root graph, subgraphs and cluster subgraphs, respectively
   GENCS_ATTRS = {
-    "Damping"             => { :usedBy => "G",    :type => :EscString },
-    "K"                   => { :usedBy => "GC",   :type => :EscString },
+    "Damping"             => { :usedBy => "G",    :type => :GvDouble },
+    "K"                   => { :usedBy => "GC",   :type => :GvDouble },
     "URL"                 => { :usedBy => "ENGC", :type => :EscString },
     "arrowhead"           => { :usedBy => "E",    :type => :EscString },
-    "arrowsize"           => { :usedBy => "E",    :type => :EscString },
+    "arrowsize"           => { :usedBy => "E",    :type => :GvDouble },
     "arrowtail"           => { :usedBy => "E",    :type => :EscString },
     "aspect"              => { :usedBy => "G",    :type => :EscString },
     "bb"                  => { :usedBy => "G",    :type => :EscString },
@@ -134,26 +135,26 @@ module Constants
     "concentrate"         => { :usedBy => "G",    :type => :EscString },
     "constraint"          => { :usedBy => "E",    :type => :EscString },
     "decorate"            => { :usedBy => "E",    :type => :EscString },
-    "defaultdist"         => { :usedBy => "G",    :type => :EscString },
+    "defaultdist"         => { :usedBy => "G",    :type => :GvDouble },
     "dim"                 => { :usedBy => "G",    :type => :EscString },
     "dimen"               => { :usedBy => "G",    :type => :EscString },
     "dir"                 => { :usedBy => "E",    :type => :EscString },
     "diredgeconstraints"  => { :usedBy => "G",    :type => :EscString },
-    "distortion"          => { :usedBy => "N",    :type => :EscString },
-    "dpi"                 => { :usedBy => "G",    :type => :EscString },
+    "distortion"          => { :usedBy => "N",    :type => :GvDouble },
+    "dpi"                 => { :usedBy => "G",    :type => :GvDouble },
     "edgeURL"             => { :usedBy => "E",    :type => :EscString },
     "edgehref"            => { :usedBy => "E",    :type => :EscString },
     "edgetarget"          => { :usedBy => "E",    :type => :EscString },
     "edgetooltip"         => { :usedBy => "E",    :type => :EscString },
-    "epsilon"             => { :usedBy => "G",    :type => :EscString },
-    "esep"                => { :usedBy => "G",    :type => :EscString },
+    "epsilon"             => { :usedBy => "G",    :type => :GvDouble },
+    "esep"                => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
     "fillcolor"           => { :usedBy => "NC",   :type => :EscString },
     "fixedsize"           => { :usedBy => "N",    :type => :EscString },
     "fontcolor"           => { :usedBy => "ENGC", :type => :EscString },
     "fontname"            => { :usedBy => "ENGC", :type => :EscString },
     "fontnames"           => { :usedBy => "G",    :type => :EscString },
     "fontpath"            => { :usedBy => "G",    :type => :EscString },
-    "fontsize"            => { :usedBy => "ENGC", :type => :EscString },
+    "fontsize"            => { :usedBy => "ENGC", :type => :GvDouble },
     "group"               => { :usedBy => "N",    :type => :EscString },
     "headURL"             => { :usedBy => "E",    :type => :EscString },
     "headclip"            => { :usedBy => "E",    :type => :EscString },
@@ -162,7 +163,7 @@ module Constants
     "headport"            => { :usedBy => "E",    :type => :EscString },
     "headtarget"          => { :usedBy => "E",    :type => :EscString },
     "headtooltip"         => { :usedBy => "E",    :type => :EscString },
-    "height"              => { :usedBy => "N",    :type => :EscString },
+    "height"              => { :usedBy => "N",    :type => :GvDouble },
     "href"                => { :usedBy => "NE",   :type => :EscString },
     "html"                => { :usedBy => "N",    :type => :HtmlString }, # API extension -- Deprecated
     "id"                  => { :usedBy => "ENG",  :type => :EscString },
@@ -170,12 +171,12 @@ module Constants
     "imagescale"          => { :usedBy => "N",    :type => :EscString },
     "label"               => { :usedBy => "ENGC", :type => :LblString },
     "labelURL"            => { :usedBy => "E",    :type => :EscString },
-    "labelangle"          => { :usedBy => "E",    :type => :EscString },
-    "labeldistance"       => { :usedBy => "E",    :type => :EscString },
+    "labelangle"          => { :usedBy => "E",    :type => :GvDouble },
+    "labeldistance"       => { :usedBy => "E",    :type => :GvDouble },
     "labelfloat"          => { :usedBy => "E",    :type => :EscString },
     "labelfontcolor"      => { :usedBy => "E",    :type => :EscString },
     "labelfontname"       => { :usedBy => "E",    :type => :EscString },
-    "labelfontsize"       => { :usedBy => "E",    :type => :EscString },
+    "labelfontsize"       => { :usedBy => "E",    :type => :GvDouble },
     "labelhref"           => { :usedBy => "E",    :type => :EscString },
     "labeljust"           => { :usedBy => "GC",   :type => :EscString },
     "labelloc"            => { :usedBy => "GCN",  :type => :EscString },
@@ -186,64 +187,66 @@ module Constants
     "layers"              => { :usedBy => "G",    :type => :EscString },
     "layersep"            => { :usedBy => "G",    :type => :EscString },
     "layout"              => { :usedBy => "G",    :type => :EscString },
-    "len"                 => { :usedBy => "E",    :type => :EscString },
+    "len"                 => { :usedBy => "E",    :type => :GvDouble },
     "levels"              => { :usedBy => "G",    :type => :EscString },
-    "levelsgap"           => { :usedBy => "G",    :type => :EscString },
+    "levelsgap"           => { :usedBy => "G",    :type => :GvDouble },
     "lhead"               => { :usedBy => "E",    :type => :EscString },
+    "lheight"             => { :usedBy => "GC",   :type => :GvDouble },
     "lp"                  => { :usedBy => "EGC",  :type => :EscString },
     "ltail"               => { :usedBy => "E",    :type => :EscString },
-    "margin"              => { :usedBy => "NG",   :type => :EscString },
+    "lweight"             => { :usedBy => "GC",   :type => :GvDouble },
+    "margin"              => { :usedBy => "NG",   :type => :EscString }, # GvDouble , pointf
     "maxiter"             => { :usedBy => "G",    :type => :EscString },
-    "mclimit"             => { :usedBy => "G",    :type => :EscString },
-    "mindist"             => { :usedBy => "G",    :type => :EscString },
+    "mclimit"             => { :usedBy => "G",    :type => :GvDouble },
+    "mindist"             => { :usedBy => "G",    :type => :GvDouble },
     "minlen"              => { :usedBy => "E",    :type => :EscString },
     "mode"                => { :usedBy => "G",    :type => :EscString },
     "model"               => { :usedBy => "G",    :type => :EscString },
     "mosek"               => { :usedBy => "G",    :type => :EscString },
-    "nodesep"             => { :usedBy => "G",    :type => :EscString },
+    "nodesep"             => { :usedBy => "G",    :type => :GvDouble },
     "nojustify"           => { :usedBy => "GCNE", :type => :EscString },
     "normalize"           => { :usedBy => "G",    :type => :EscString },
-    "nslimit"             => { :usedBy => "G",    :type => :EscString },
-    "nslimit1"            => { :usedBy => "G",    :type => :EscString },
+    "nslimit"             => { :usedBy => "G",    :type => :GvDouble },
+    "nslimit1"            => { :usedBy => "G",    :type => :GvDouble },
     "ordering"            => { :usedBy => "G",    :type => :EscString },
-    "orientation"         => { :usedBy => "NG",   :type => :EscString },
+    "orientation"         => { :usedBy => "NG",   :type => :GvDouble },
     "outputorder"         => { :usedBy => "G",    :type => :EscString },
     "overlap"             => { :usedBy => "G",    :type => :EscString },
-    "overlap_scaling"     => { :usedBy => "G",    :type => :EscString },
+    "overlap_scaling"     => { :usedBy => "G",    :type => :GvDouble },
     "pack"                => { :usedBy => "G",    :type => :EscString },
     "packmode"            => { :usedBy => "G",    :type => :EscString },
-    "pad"                 => { :usedBy => "G",    :type => :EscString },
-    "page"                => { :usedBy => "G",    :type => :EscString },
+    "pad"                 => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
+    "page"                => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
     "pagedir"             => { :usedBy => "G",    :type => :EscString },
     "pencolor"            => { :usedBy => "C",    :type => :EscString },
-    "penwidth"            => { :usedBy => "CNE",  :type => :EscString },
+    "penwidth"            => { :usedBy => "CNE",  :type => :GvDouble },
     "peripheries"         => { :usedBy => "NC",   :type => :EscString },
     "pin"                 => { :usedBy => "N",    :type => :EscString },
     "pos"                 => { :usedBy => "EN",   :type => :EscString },
     "quadtree"            => { :usedBy => "G",    :type => :EscString },
-    "quantum"             => { :usedBy => "G",    :type => :EscString },
+    "quantum"             => { :usedBy => "G",    :type => :GvDouble },
     "rank"                => { :usedBy => "S",    :type => :EscString },
     "rankdir"             => { :usedBy => "G",    :type => :EscString },
-    "ranksep"             => { :usedBy => "G",    :type => :EscString },
-    "ratio"               => { :usedBy => "G",    :type => :EscString },
+    "ranksep"             => { :usedBy => "G",    :type => :EscString }, # GvDouble, doubleList
+    "ratio"               => { :usedBy => "G",    :type => :EscString }, # GvDouble, String
     "rects"               => { :usedBy => "N",    :type => :EscString },
     "regular"             => { :usedBy => "N",    :type => :EscString },
     "remincross"          => { :usedBy => "G",    :type => :EscString },
-    "repulsiveforce"      => { :usedBy => "G",    :type => :EscString },
-    "resolution"          => { :usedBy => "G",    :type => :EscString },
+    "repulsiveforce"      => { :usedBy => "G",    :type => :GvDouble },
+    "resolution"          => { :usedBy => "G",    :type => :GvDouble },
     "root"                => { :usedBy => "GN",   :type => :EscString },
     "rotate"              => { :usedBy => "G",    :type => :EscString },
     "samehead"            => { :usedBy => "E",    :type => :EscString },
     "sametail"            => { :usedBy => "E",    :type => :EscString },
     "samplepoints"        => { :usedBy => "G",    :type => :EscString },
     "searchsize"          => { :usedBy => "G",    :type => :EscString },
-    "sep"                 => { :usedBy => "G",    :type => :EscString },
+    "sep"                 => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
     "shape"               => { :usedBy => "N",    :type => :EscString },
     "shapefile"           => { :usedBy => "N",    :type => :EscString },
     "showboxes"           => { :usedBy => "ENG",  :type => :EscString },
     "sides"               => { :usedBy => "N",    :type => :EscString },
-    "size"                => { :usedBy => "NG",   :type => :EscString },
-    "skew"                => { :usedBy => "N",    :type => :EscString },
+    "size"                => { :usedBy => "NG",   :type => :EscString }, # GvDouble , pointf
+    "skew"                => { :usedBy => "N",    :type => :GvDouble },
     "smoothing"           => { :usedBy => "G",    :type => :EscString },
     "sortv"               => { :usedBy => "GCN",  :type => :EscString },
     "splines"             => { :usedBy => "G",    :type => :EscString },
@@ -262,10 +265,10 @@ module Constants
     "truecolor"           => { :usedBy => "G",    :type => :EscString },
     "vertices"            => { :usedBy => "N",    :type => :EscString },
     "viewport"            => { :usedBy => "G",    :type => :EscString },
-    "voro_margin"         => { :usedBy => "G",    :type => :EscString },
-    "weight"              => { :usedBy => "E",    :type => :EscString },
-    "width"               => { :usedBy => "N",    :type => :EscString },
-    "z"                   => { :usedBy => "N",    :type => :EscString }
+    "voro_margin"         => { :usedBy => "G",    :type => :GvDouble },
+    "weight"              => { :usedBy => "E",    :type => :GvDouble },
+    "width"               => { :usedBy => "N",    :type => :GvDouble },
+    "z"                   => { :usedBy => "N",    :type => :GvDouble }
   }
 
   ## Const: Graph attributs

data/lib/graphviz/edge.rb

@@ -52,11 +52,13 @@ class GraphViz
 	    @oGParrent = oGParrent
 
       @oAttrEdge = GraphViz::Attrs::new( nil, "edge", EDGESATTRS )
+      
+      @index = nil
     end
 
     # Return the node one as string (so with port if any)
-    def node_one
-      if @xNodeOnePort.nil?
+    def node_one( with_port = true )
+      if @xNodeOnePort.nil? or with_port == false
 	      GraphViz.escape(@xNodeOne)
       else
         GraphViz.escape(@xNodeOne, true) + ":#{@xNodeOnePort}"
@@ -64,14 +66,24 @@ class GraphViz
     end
 
     # Return the node two as string (so with port if any)
-    def node_two
-      if @xNodeTwoPort.nil?
+    def node_two( with_port = true )
+      if @xNodeTwoPort.nil? or with_port == false
 	      GraphViz.escape(@xNodeTwo) 
 	    else 
 	      GraphViz.escape(@xNodeTwo, true) + ":#{@xNodeTwoPort}"
       end
     end
     
+    #
+	  # Return the index of the edge
+	  #
+	  def index
+	    @index
+    end
+    def index=(i) #:nodoc:
+      @index = i if @index == nil
+    end
+    
     # 
     # Set value +xAttrValue+ to the edge attribut +xAttrName+
     # 
@@ -91,7 +103,11 @@ class GraphViz
           self[key] = value
         end
       else
-        @oAttrEdge[xAttrName.to_s].clone
+        if @oAttrEdge[xAttrName.to_s]
+          @oAttrEdge[xAttrName.to_s].clone 
+        else
+          nil
+        end
       end
     end
     
@@ -122,6 +138,7 @@ class GraphViz
     # Add edge options
     # use edge.<option>=<value> or edge.<option>( <value> )
     def method_missing( idName, *args, &block ) #:nodoc:
+      return if idName == :to_ary # ruby 1.9.2 fix
       xName = idName.id2name
       
       self[xName.gsub( /=$/, "" )]=args[0]

data/lib/graphviz/elements.rb

@@ -0,0 +1,39 @@
+class GraphViz
+  class Elements
+    def initialize
+      @elements = Array.new
+      @elements_hash_by_type = Hash.new
+    end
+    
+    def push( obj )
+      @elements.push( obj )
+      if @elements_hash_by_type[obj['type']].nil?
+        @elements_hash_by_type[obj['type']] = Array.new
+      end
+      
+      @elements_hash_by_type[obj['type']].push( obj )
+    end
+    
+    def each( &b )
+      @elements.each do |e|
+        yield( e )
+      end
+    end
+    
+    def size_of( type )
+      if @elements_hash_by_type[type].nil?
+        return 0
+      else
+        return @elements_hash_by_type[type].size
+      end
+    end
+    
+    def []( index, type = nil )
+      if type.nil?
+        return @elements[index]
+      else
+        return @elements_hash_by_type[type][index]
+      end
+    end
+  end
+end

data/lib/graphviz/graphml.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2010 Gregoire Lejeune <gregoire.lejeune@free.fr>
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+
+require 'graphviz'
+require 'rexml/document'
+
+class GraphViz
+  class GraphML
+    attr_reader :attributs
+    attr_accessor :graph
+  
+    DEST = {
+      'node'  => [:nodes],
+      'edge'  => [:edges],
+      'graph' => [:graphs],
+      'all'   => [:nodes, :edges, :graphs]
+    }
+    
+    GTYPE = {
+      'directed' => :digraph,
+      'undirected' => :graph
+    }
+    
+    def initialize( xFile )
+      @xmlDoc = REXML::Document::new( File::new( xFile ) )
+      @attributs = {
+        :nodes => {},
+        :edges => {},
+        :graphs => {}
+      }
+      @graph = nil
+      @current_attr = nil
+      @current_node = nil
+      @current_edge = nil
+      @current_graph = nil
+      
+      parse( @xmlDoc.root )
+    end
+    
+    def parse( node )
+      #begin
+        send( node.name.to_sym, node )
+      #rescue NoMethodError => e
+      #  raise "ERROR node #{node.name} can be root"
+      #end
+    end
+    
+    def graphml( node )
+      node.each_element( ) do |child|
+        #begin
+          send( "graphml_#{child.name}".to_sym, child )
+        #rescue NoMethodError => e
+        #  raise "ERROR node #{child.name} can be child of graphml"
+        #end
+      end
+    end
+    
+    def graphml_key( node )
+      id = node.attributes['id']
+      @current_attr = {
+        :name => node.attributes['attr.name'],
+        :type => node.attributes['attr.type']
+      }    
+      DEST[node.attributes['for']].each do |d|
+        @attributs[d][id] = @current_attr
+      end
+      
+      node.each_element( ) do |child|
+        begin
+          send( "graphml_key_#{child.name}".to_sym, child )
+        rescue NoMethodError => e
+          raise "ERROR node #{child.name} can be child of graphml"
+        end
+      end
+      
+      @current_attr = nil
+    end
+    
+    def graphml_key_default( node )
+      @current_attr[:default] = node.texts().to_s
+    end
+    
+    def graphml_graph( node )
+      @current_node = nil
+      
+      if @current_graph.nil?
+        @graph = GraphViz.new( node.attributes['id'], :type => GTYPE[node.attributes['edgedefault']] )
+        @current_graph = @graph
+        previous_graph = @graph
+      else
+        previous_graph = @current_graph      
+        @current_graph = previous_graph.add_graph( node.attributes['id'] )
+      end
+      
+      @attributs[:graphs].each do |id, data|
+        @current_graph.graph[data[:name]] = data[:default] if data.has_key?(:default)
+      end
+      @attributs[:nodes].each do |id, data|
+        @current_graph.node[data[:name]] = data[:default] if data.has_key?(:default)
+      end
+      @attributs[:edges].each do |id, data|
+        @current_graph.edge[data[:name]] = data[:default] if data.has_key?(:default)
+      end
+          
+      node.each_element( ) do |child|
+        #begin
+          send( "graphml_graph_#{child.name}".to_sym, child )
+        #rescue NoMethodError => e
+        #  raise "ERROR node #{child.name} can be child of graphml"
+        #end
+      end
+      
+      @current_graph = previous_graph
+    end
+    
+    def graphml_graph_data( node )
+      @current_graph[@attributs[:graphs][node.attributes['key']][:name]] = node.texts().to_s
+    end
+    
+    def graphml_graph_node( node )
+      @current_node = {}
+  
+      node.each_element( ) do |child|
+        case child.name
+        when "graph"
+          graphml_graph( child )
+        else
+          begin
+            send( "graphml_graph_node_#{child.name}".to_sym, child )
+          rescue NoMethodError => e
+            raise "ERROR node #{child.name} can be child of graphml"
+          end
+        end
+      end
+      
+      unless @current_node.nil?
+        node = @current_graph.add_node( node.attributes['id'] )
+        @current_node.each do |k, v|
+          node[k] = v
+        end
+      end
+      
+      @current_node = nil
+    end
+    
+    def graphml_graph_node_data( node )
+      @current_node[@attributs[:nodes][node.attributes['key']][:name]] = node.texts().to_s
+    end
+    
+    def graphml_graph_node_port( node )
+      @current_node[:shape] = :record
+      port = node.attributes['name']
+      if @current_node[:label]
+        label = @current_node[:label].gsub( "{", "" ).gsub( "}", "" )
+        @current_node[:label] = "#{label}|<#{port}> #{port}"
+      else
+        @current_node[:label] = "<#{port}> #{port}"
+      end
+    end
+    
+    def graphml_graph_edge( node )
+      source = node.attributes['source']
+      source = {source => node.attributes['sourceport']} if node.attributes['sourceport']
+      target = node.attributes['target']
+      target = {target => node.attributes['targetport']} if node.attributes['targetport']
+      
+      @current_edge = @current_graph.add_edge( source, target )
+  
+      node.each_element( ) do |child|
+        #begin
+          send( "graphml_graph_edge_#{child.name}".to_sym, child )
+        #rescue NoMethodError => e
+        #  raise "ERROR node #{child.name} can be child of graphml"
+        #end
+      end
+      
+      @current_edge = nil
+    end
+  
+    def graphml_graph_edge_data( node )
+      @current_edge[@attributs[:edges][node.attributes['key']][:name]] = node.texts().to_s
+    end
+    
+    def graphml_graph_hyperedge( node )
+      list = []
+      
+      node.each_element( ) do |child|
+        if child.name == "endpoint"
+          if child.attributes['port']
+            list << { child.attributes['node'] => child.attributes['port'] }
+          else
+            list << child.attributes['node']
+          end
+        end
+      end
+      
+      list.each { |s|
+        list.each { |t|
+          @current_graph.add_edge( s, t ) unless s == t
+        }
+      } 
+    end
+  end
+end