luquet-ruby-graphviz 0.9.5

data/lib/graphviz/node.rb

@@ -0,0 +1,129 @@
+# Copyright (C) 2004, 2005, 2006, 2007, 2008 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/attrs'
+require 'graphviz/constants'
+
+class GraphViz
+  class Node
+    include Constants
+    @xNodeName
+    @oAttrNode
+    @oGParrent
+    
+    # 
+    # Create a new node
+    # 
+    # In:
+    # * xNodeName : Name of the node
+    # * oGParrent : Graph 
+    # 
+    def initialize( xNodeName, oGParrent = nil )
+      @xNodeName = xNodeName
+      @oGParrent = oGParrent
+      @oAttrNode = GraphViz::Attrs::new( nil, "node", NODESATTRS )
+    end
+
+    # 
+    # Get the node name
+    # 
+    def name
+	    @xNodeName.clone
+	  end
+	
+	  # 
+    # Set value +xAttrValue+ to the node attribut +xAttrName+
+    # 
+    def []=( xAttrName, xAttrValue )
+      xAttrValue = xAttrValue.to_s if xAttrValue.class == Symbol
+      @oAttrNode[xAttrName.to_s] = xAttrValue
+    end
+
+    # 
+    # Get the value of the node attribut +xAttrName+
+    # 
+    def []( xAttrName )
+      @oAttrNode[xAttrName.to_s].clone
+    end
+
+    # 
+    # Create an edge between the current node and the node +oNode+
+    # 
+    def <<( oNode )
+      if( oNode.class == Array ) 
+        oNode.each do |no|
+          self << no
+        end
+      else
+        return GraphViz::commonGraph( oNode, self ).add_edge( self, oNode )
+      end
+    end
+    alias :> :<<
+    alias :- :<<
+    alias :>> :<<
+    
+    #
+    # Set node attributs
+    #
+    # Example :
+    #   n = graph.add_node( ... )
+    #   ...
+    #   n.set { |_n|
+    #     _n.color = "blue"
+    #     _n.fontcolor = "red"
+    #   }
+    # 
+    def set( &b )
+      yield( self )
+    end
+    
+    # Add node options
+    # use node.<option>=<value> or node.<option>( <value> )
+    def method_missing( idName, *args, &block ) #:nodoc:
+      xName = idName.id2name
+      
+      self[xName.gsub( /=$/, "" )]=args[0]
+    end
+    
+    def pg #:nodoc:
+      @oGParrent
+    end
+    
+    def output #:nodoc:
+      #xNodeName = @xNodeName.clone
+      #xNodeName = '"' << xNodeName << '"' if xNodeName.match( /^[a-zA-Z_]+[a-zA-Z0-9_\.]*$/ ).nil?
+      xNodeName = GraphViz.escape(@xNodeName)
+      
+      xOut = "" << xNodeName
+      xAttr = ""
+      xSeparator = ""
+      @oAttrNode.data.each do |k, v|
+	      if k == "html"
+		      xAttr << xSeparator + "label = <" + v + ">"
+		    else
+          xAttr << xSeparator + k + " = " + GraphViz.escape(v, true)
+		    end
+        xSeparator = ", "
+      end
+      if xAttr.length > 0
+        xOut << " [" + xAttr + "]"
+      end
+      xOut << ";"
+
+      return( xOut )
+    end
+  end
+end

data/lib/graphviz/parser.rb

@@ -0,0 +1,249 @@
+require 'rubygems'
+require 'treetop'
+
+Treetop.load File.dirname(__FILE__) + '/dot.treetop'
+
+class GraphViz
+  class Parser
+
+    class Context
+      def initialize
+        @graph = nil
+        @nodes = {}
+        @edges = []
+        @options = {
+          :node => {},
+          :edge => {}
+        }
+      end
+      
+      def graph
+        @graph
+      end
+      
+      def graph=(g)
+        @graph = g
+      end
+      
+      def nodes
+        @nodes
+      end
+      
+      def edges
+        @edges
+      end
+      
+      def options
+        @options
+      end
+      
+      def options=(o)
+        @options = o
+      end
+    end
+    
+    class Graph < Treetop::Runtime::SyntaxNode
+      def eval( context, hOpts )
+        # puts "GRAPH TYPE = #{type.text_value}"
+        # puts "GRAPH NAME = #{name.text_value}"
+        
+        hOpts = hOpts[0].merge( {:type => type.text_value} )
+        
+        # Create Graph
+        context.graph = GraphViz.new( name.text_value.gsub(/"/, ""), hOpts )
+        
+        # Eval cluster
+        cluster.eval( context )
+        
+        return context.graph
+      end
+    end
+    
+    class Cluster < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        content.elements.each do |e|
+          e.eval( context )
+        end
+      end
+    end
+    
+    class GraphPreference < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        # puts "GRAPH PREFERENCE : "
+        # puts "  #{key.text_value} = #{value.text_value.gsub(/"/, "")}"
+        context.graph[key.text_value] = value.text_value.gsub(/"/, "")
+      end
+    end
+    
+    class NamedGraphPreference < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        # puts "GRAPH PREFERENCES :"
+        options.eval().each do |k,v|
+          context.graph[k] = v
+        end
+      end
+    end
+    
+    class NodePreference < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        # puts "NODE PREFERENCES :"
+        context.options[:node] = context.options[:node].merge( options.eval() )
+      end
+    end
+    
+    class EdgePreference < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        # puts "EDGE PREFERENCES :"
+        context.options[:edge] = context.options[:edge].merge( options.eval() )
+      end
+    end
+    
+    class Node < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        node_name = name.text_value.gsub( /"/, "" )
+        # puts "NODE NAME = #{node_name}"
+        # puts "OPTIONS = "
+        
+        # Create node
+        node = context.nodes[node_name] || context.graph.add_node( node_name )
+    
+        # Add global options
+        context.options[:node].each do |k, v|
+          node[k] = v
+        end
+        
+        # Add custom options
+        unless options.terminal?
+          options.eval().each do |k, v|
+            node[k] = v
+          end
+        end
+        
+        # Save node
+        context.nodes[node_name] = node
+      end
+    end
+    
+    class Edge < Treetop::Runtime::SyntaxNode
+      def create_node( name, context )
+        # puts "  NEED TO CREATE NODE : #{name}"
+        # Create the node
+        node = context.graph.add_node( name )
+        
+        # Add global options
+        context.options[:node].each do |k, v|
+          node[k] = v
+        end
+        
+        # Save node
+        context.nodes[name] = node
+      end
+      
+      def create_edge( one, two, edge_options, context )
+        # Create edge
+        edge = context.graph.add_edge( one, two )
+        
+        # Add global options
+        context.options[:edge].each do |k, v|
+          edge[k] = v
+        end
+        
+        # Add custom options
+        edge_options.each do |k, v|
+          edge[k] = v
+        end
+        
+        # Save edge
+        context.edges << edge
+      end
+      
+      def eval( context )
+        one_name = node_one.text_value.gsub( /"/, "" )
+        two_name = node_two.text_value.gsub( /"/, "" )
+        # puts "EDGE"
+        # puts "NODE ONE = #{one_name}"
+        # puts "NODE TWO = #{two_name}"
+        # puts "OPTIONS = "
+        
+        # Get or create node one
+        one = context.nodes[one_name] || create_node( one_name, context )
+    
+        # Get or create node two
+        two = context.nodes[two_name] || create_node( two_name, context )
+        
+        # Get options 
+        edge_options = {}
+        edge_options = options.eval() unless options.terminal?
+        
+        # Create edge
+        create_edge( one, two, edge_options, context )
+        
+        last_node = two
+        other_nodes.elements.each do |e|
+          new_node_name = e.next_node.text_value.gsub( /"/, "" )
+          # puts "OTHER NODE : #{new_node_name}"
+          
+          new_node = context.nodes[new_node_name] || create_node( new_node_name, context )
+          create_edge( last_node, new_node, edge_options, context )
+          
+          last_node = new_node
+        end
+      end
+    end
+    
+    class Subgraph < Treetop::Runtime::SyntaxNode
+      def eval( context )
+        # puts "CREATE SUBGRAPH : #{name.text_value}"
+        
+        # Save options
+        saved_options = context.options.clone
+        # Save graph 
+        saved_graph = context.graph
+        
+        # Create Graph
+        context.graph = context.graph.add_graph( name.text_value.gsub(/"/, "") )
+        #context.options = {
+        #  :node => {},
+        #  :edge => {}
+        #}
+        
+        # Eval cluster
+        cluster.eval( context )
+        
+        # Reinitialize graph and options
+        context.graph = saved_graph
+        context.options = saved_options
+      end
+    end
+    
+    class Options < Treetop::Runtime::SyntaxNode
+      def eval
+        options = {}
+        elements[2].elements.each do |e|
+          # puts "  #{e.elements[0].text_value} = #{e.elements[4].text_value}"
+          options[e.elements[0].text_value] = e.elements[4].text_value.gsub( /"/, "" )
+        end
+        # puts "  #{elements[3].text_value} = #{elements[7].text_value}"
+        options[elements[3].text_value] = elements[7].text_value.gsub( /"/, "" )
+    
+        return options
+      end
+    end
+
+    class Rank < Treetop::Runtime::SyntaxNode
+      def eval( context )
+      end
+    end
+
+    def self.parse( file, *hOpts, &block )
+      dot = open(file).read
+      parser = DotParser.new()
+      tree = parser.parse( dot )
+      graph = tree.eval( GraphViz::Parser::Context.new(), hOpts )
+      
+      yield( graph ) if( block and graph.nil? == false )
+      
+      return graph
+    end
+  end
+end

data/lib/graphviz/xml.rb

@@ -0,0 +1,131 @@
+# Copyright (C) 2004, 2005, 2006, 2007, 2008 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 XML
+    
+    @oReXML
+    @oGraph 
+    @xNodeName
+	  @bShowText
+	  @bShowAttrs
+    
+    # 
+    # Generate the graph
+    # 
+    # Options :
+    # * :output : Output format (Constants::FORMATS)
+    # * :file : Output file name
+    # * :use : Program to use (Constants::PROGRAMS)
+    # * :path : Program PATH
+    # * :<format> => <file> : <file> can be
+    #   * a file name
+    #   * nil, then the output will be printed to STDOUT
+    #   * String, then the output will be returned as a String
+    # * :errors : DOT error level (default 1)
+    #   * 0 = Error + Warning
+    #   * 1 = Error
+    #   * 2 = none
+    # 
+    def output( *hOpt )
+      @oGraph.output( *hOpt )
+    end
+    
+    private
+    
+    # 
+    # Create a graph from a XML file
+    # 
+    # In:
+    # * xFile : XML File
+    # * *hOpt : Graph options
+    # 
+    def initialize( xFile, *hOpt )
+      @xNodeName = "00000"
+	    @bShowText = true
+	    @bShowAttrs = true
+
+      if hOpt.nil? == false and hOpt[0].nil? == false
+        hOpt[0].each do |xKey, xValue|
+          case xKey.to_s
+            when "text"
+              @bShowText = xValue
+		          hOpt[0].delete( xKey )
+            when "attrs"
+              @bShowAttrs = xValue
+		          hOpt[0].delete( xKey )
+          end
+        end
+      end
+
+      @oReXML = REXML::Document::new( File::new( xFile ) )
+      @oGraph = GraphViz::new( "XML", *hOpt ) 
+      _init( @oReXML.root() )
+    end
+    
+    def _init( oXMLNode ) #:nodoc:
+      xLocalNodeName = @xNodeName.clone
+      @xNodeName.succ!
+      
+      label = oXMLNode.name
+      if oXMLNode.has_attributes? == true and @bShowAttrs == true
+        label = "{ " + oXMLNode.name 
+		
+		    oXMLNode.attributes.each do |xName, xValue|
+		      label << "| { #{xName} | #{xValue} } " 
+		    end
+		
+		    label << "}"
+	    end
+      @oGraph.add_node( xLocalNodeName, "label" => label, "color" => "blue", "shape" => "record" )
+
+      ## Act: Search and add Text nodes
+      if oXMLNode.has_text? == true and @bShowText == true
+        xTextNodeName = xLocalNodeName.clone
+        xTextNodeName << "111"
+        
+        xText = ""
+        xSep = ""
+        oXMLNode.texts().each do |l|
+          x = l.value.chomp.strip
+          if x.length > 0
+            xText << xSep << x
+            xSep = "\n"
+          end
+        end
+
+        if xText.length > 0
+          @oGraph.add_node( xTextNodeName, "label" => xText, "color" => "black", "shape" => "ellipse" )
+          @oGraph.add_edge( xLocalNodeName, xTextNodeName )
+        end
+      end
+
+      ## Act: Search and add attributs
+      ## TODO
+
+      oXMLNode.each_element( ) do |oXMLChild|
+        xChildNodeName = _init( oXMLChild )
+        @oGraph.add_edge( xLocalNodeName, xChildNodeName )
+      end
+
+      return( xLocalNodeName )
+    end
+
+  end
+end