ruby-graphviz_c 1.1.0

data/lib/graphviz/family_tree/sibling.rb

@@ -0,0 +1,13 @@
+class GraphViz
+  class FamilyTree
+    class Sibling
+      def initialize( bns, parents )
+        @brothers_and_sisters = bns
+        @brothers_and_sisters.each do |person|
+          person.sibling = self
+        end
+        @parents = parents
+      end
+    end
+  end
+end

data/lib/graphviz/family_tree.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+
+require 'rubygems'
+require 'graphviz'
+require 'graphviz/family_tree/generation'
+require 'graphviz/family_tree/person'
+require 'graphviz/family_tree/couple'
+require 'graphviz/family_tree/sibling'
+
+class GraphViz
+  class FamilyTree
+    # Create a new family tree
+    #
+    #   require 'graphviz/family_tree'
+    #   t = GraphViz::FamilyTree.new do
+    #     ...
+    #   end
+    def initialize( &block )
+      @persons = {}
+      @graph = GraphViz.new( "FamilyTree", :use => :neato )
+      @generation_number = 0
+      @generations = []
+      @couples = {}
+
+      instance_eval(&block) if block
+    end
+
+    # Add a new generation in the tree
+    #
+    #   require 'graphviz/family_tree'
+    #   t = GraphViz::FamilyTree.new do
+    #     generation do
+    #       ...
+    #     end
+    #     generation do
+    #       ...
+    #     end
+    #   end
+    def generation( &b )
+      gen = GraphViz::FamilyTree::Generation.new( @graph, @persons, self, @generation_number )
+      gen.make( &b )
+      @generations << gen
+      @generation_number += 1
+    end
+
+    def persons #:nodoc:
+      @persons ||= {}
+    end
+
+    def add_couple( x, y, node ) #:nodoc:
+      @couples[x] = {} if @couples[x].nil?
+      @couples[x][y] = GraphViz::FamilyTree::Couple.new( @graph, node, [x, y] )
+      @couples[y] = {} if @couples[y].nil?
+      @couples[y][x] = @couples[x][y]
+    end
+
+    # Get a couple (GraphViz::FamilyTree::Couple)
+    def couple( x, y )
+      @couples[x][y]
+    end
+
+    def method_missing(sym, *args, &block) #:nodoc:
+      persons[sym.to_s]
+    end
+
+    # Family size
+    def size
+      @persons.size
+    end
+
+    # Get the graph
+    def graph
+      maxY = @generations.size
+      biggestGen, maxX = biggestGenerationNumberAndSize
+
+      puts "#{maxY} generations"
+      puts "Plus grosse generation : ##{biggestGen} avec #{maxX} personnes"
+
+      puts "traitement des générations..."
+
+      puts "  #{biggestGen}:"
+      @generations[biggestGen].persons.each do |id, person|
+        puts "    - #{id} : #{person.class}"
+      end
+
+      puts "  Up..."
+      (0...biggestGen).reverse_each do |genNumber|
+        puts "  #{genNumber}:"
+        @generations[genNumber].persons.each do |id, person|
+          puts "    - #{id} : #{person.class}"
+        end
+      end
+
+      puts "  Down..."
+      ((biggestGen+1)...maxY).each do |genNumber|
+        puts "  #{genNumber}:"
+        @generations[genNumber].persons.each do |id, person|
+          puts "    - #{id} : #{person.class}"
+        end
+      end
+
+      @graph
+    end
+
+    private
+    def biggestGenerationNumberAndSize
+      size = 0
+      number = 0
+      @generations.each do |gen|
+        if gen.size > size
+          size = gen.size
+          number = gen.number
+        end
+      end
+      return number, size
+    end
+  end
+end

data/lib/graphviz/graphml.rb

@@ -0,0 +1,268 @@
+#!/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 GraphMLError < RuntimeError
+  end
+
+  class GraphML
+    attr_reader :attributes
+    def attributs
+       warn "`GraphViz::GraphML#attributs` is deprecated, please, use `GraphViz::GraphML#attributes`"
+       return @attributes
+    end
+
+    # The GraphViz object
+    attr_accessor :graph
+
+    DEST = {
+      'node'      => [:nodes],
+      'edge'      => [:edges],
+      'graph'     => [:graphs],
+      'graphml'   => [:graphml],
+      'hyperedge' => [:hyperedge],
+      'port'      => [:port],
+      'endpoint'  => [:endpoint],
+      'all'       => [:nodes, :edges, :graphs, :graphml, :hyperedge, :port, :endpoint]
+    }
+
+    GTYPE = {
+      'directed' => :digraph,
+      'undirected' => :graph
+    }
+
+    # Create a new GraphViz object from a GraphML file of string
+    def initialize( file_or_str )
+      data = ((File.file?( file_or_str )) ? File::new(file_or_str) : file_or_str)
+      @xmlDoc = REXML::Document::new( data )
+      @attributes = {
+        :nodes => {},
+        :edges => {},
+        :graphs => {},
+        :graphml => {},
+        :endpoint => {},
+        :port => {},
+        :hyperedge => {}
+      }
+      @ignored_keys = []
+      @graph = nil
+      @current_attr = nil
+      @current_node = nil
+      @current_edge = nil
+      @current_graph = nil
+
+      parse( @xmlDoc.root )
+    end
+
+    def parse( node ) #:nodoc:
+      send( node.name.to_sym, node )
+    end
+
+    def graphml( node ) #:nodoc:
+      node.each_element( ) do |child|
+        begin
+          send( "graphml_#{child.name}".to_sym, child )
+        rescue NoMethodError => e
+          raise GraphMLError, "node #{child.name} can be child of graphml"
+        end
+      end
+    end
+
+    def graphml_data(node)
+       warn "graphml/data not supported!"
+    end
+
+    def graphml_key( node ) #:nodoc:
+      id = node.attributes['id']
+      @current_attr = {
+        :name => node.attributes['attr.name'],
+        :type => node.attributes['attr.type']
+      }
+      if @current_attr[:name].nil?
+        @ignored_keys << id
+      else
+        DEST[node.attributes['for']].each do |d|
+          @attributes[d][id] = @current_attr
+        end
+
+        node.each_element( ) do |child|
+          begin
+            send( "graphml_key_#{child.name}".to_sym, child )
+          rescue NoMethodError => e
+            raise GraphMLError, "node #{child.name} can be child of key"
+          end
+        end
+      end
+
+      @current_attr = nil
+    end
+
+    def graphml_key_default( node ) #:nodoc:
+      @current_attr[:default] = node.texts().join('\n')
+    end
+
+    def graphml_graph( node ) #:nodoc:
+      @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
+
+      @attributes[:graphs].each do |id, data|
+        begin
+          @current_graph.graph[data[:name]] = data[:default] if data.has_key?(:default)
+        rescue ArgumentError => e
+          warn e
+        end
+      end
+      @attributes[:nodes].each do |id, data|
+        begin
+          @current_graph.node[data[:name]] = data[:default] if data.has_key?(:default)
+        rescue ArgumentError => e
+          warn e
+        end
+      end
+      @attributes[:edges].each do |id, data|
+        begin
+          @current_graph.edge[data[:name]] = data[:default] if data.has_key?(:default)
+        rescue ArgumentError => e
+          warn e
+        end
+      end
+
+      node.each_element( ) do |child|
+        send( "graphml_graph_#{child.name}".to_sym, child )
+      end
+
+      @current_graph = previous_graph
+    end
+
+    def graphml_graph_data( node ) #:nodoc:
+      begin
+        @current_graph[@attributes[:graphs][node.attributes['key']][:name]] = node.texts().join('\n')
+      rescue ArgumentError => e
+        warn e
+      end
+    end
+
+    def graphml_graph_node( node ) #:nodoc:
+      @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 GraphMLError, "node #{child.name} can be child of node"
+          end
+        end
+      end
+
+      unless @current_node.nil?
+        node = @current_graph.add_nodes( node.attributes['id'] )
+        @current_node.each do |k, v|
+          begin
+            node[k] = v
+          rescue ArgumentError => e
+            warn e
+          end
+        end
+      end
+
+      @current_node = nil
+    end
+
+    def graphml_graph_node_data( node ) #:nodoc:
+      return if @ignored_keys.include?(node.attributes['key'])
+      begin
+        @current_node[@attributes[:nodes][node.attributes['key']][:name]] = node.texts().join('\n')
+      rescue ArgumentError => e
+        warn e
+      end
+    end
+
+    def graphml_graph_node_port( node ) #:nodoc:
+      @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 ) #:nodoc:
+      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_edges( source, target )
+
+      node.each_element( ) do |child|
+        begin
+          send( "graphml_graph_edge_#{child.name}".to_sym, child )
+        rescue NoMethodError => e
+          raise GraphMLError, "node #{child.name} can be child of edge"
+        end
+      end
+
+      @current_edge = nil
+    end
+
+    def graphml_graph_edge_data( node ) #:nodoc:
+      return if @ignored_keys.include?(node.attributes['key'])
+      begin
+        @current_edge[@attributes[:edges][node.attributes['key']][:name]] = node.texts().join('\n')
+      rescue ArgumentError => e
+        warn e
+      end
+    end
+
+    def graphml_graph_hyperedge( node ) #:nodoc:
+      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_edges( s, t ) unless s == t
+        }
+      }
+    end
+  end
+end

data/lib/graphviz/math/matrix.rb

@@ -0,0 +1,221 @@
+class GraphViz
+  class Math
+    def self.Matrix( line, column = 0, val = 0 )
+      GraphViz::Math::Matrix.new(line, column, val)
+    end
+
+    class CoordinateError < RuntimeError
+    end
+    class ValueError < RuntimeError
+    end
+
+    class Matrix
+      def initialize( line_or_array, column = 0, val = 0 )
+        if line_or_array.kind_of?(Array)
+          line = line_or_array.size
+          column = nil
+          line_or_array.size.times do |l|
+            unless line_or_array[l].kind_of?(Array)
+              raise ArgumentError, "Wrong matrix definition"
+            end
+            column = line_or_array[l].size if column.nil?
+            unless line_or_array[l].size == column
+              raise ArgumentError, "Wrong matrix definition"
+            end
+            line_or_array[l].size.times do |c|
+              unless line_or_array[l][c].kind_of?(Numeric)
+                raise ValueError, "Element at [#{l+1}, #{c+1}] is not a number"
+              end
+            end
+          end
+
+          @matrix = line_or_array
+          @line = line
+          @column = column
+        elsif line_or_array.kind_of?(Integer) and column > 0
+          @matrix = Array.new(line_or_array)
+          @matrix.size.times do |l|
+            @matrix[l] = Array.new(column)
+            @matrix[l].size.times do |c|
+              @matrix[l][c] = val
+            end
+          end
+          @line = line_or_array
+          @column = column
+        else
+          raise ArgumentError, "Wrong matrix definition"
+        end
+      end
+
+      def [](line, column)
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @matrix[line-1][column-1]
+      end
+
+      def []=( line, column, val )
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @matrix[line-1][column-1] = val
+      end
+
+      def matrix
+        @matrix
+      end
+      alias :to_a :matrix
+
+      def columns
+        @column
+      end
+
+      def lines
+        @line
+      end
+
+      def to_s
+        size = bigger
+        out = ""
+        @line.times do |line|
+          out << "["
+          @column.times do |column|
+            out << sprintf(" %1$*2$s", @matrix[line][column].to_s, size)
+          end
+          out << "]\n"
+        end
+        return out
+      end
+
+      def -(m)
+        matrix = GraphViz::Math::Matrix.new( @line, @column )
+        @line.times do |line|
+          @column.times do |column|
+            matrix[line+1, column+1] = self[line+1, column+1] - m[line+1, column+1]
+          end
+        end
+        return matrix
+      end
+
+      def *(m)
+        matrix = GraphViz::Math::Matrix.new( @line, @line )
+
+        @line.times do |line|
+          @line.times do |column|
+            l = self.line(line+1)
+            c = m.column(column+1)
+            v = 0
+            l.size.times do |i|
+              v += l[i]*c[i]
+            end
+            matrix[line+1,column+1] = v
+          end
+        end
+
+        return matrix
+      end
+
+      def line( line )
+        unless (0...@line).to_a.include?(line-1)
+          raise CoordinateError, "Line out of range (#{line} for 1..#{@line})!"
+        end
+        @matrix[line-1]
+      end
+
+      def column( column )
+        col = []
+        unless (0...@column).to_a.include?(column-1)
+          raise CoordinateError, "Column out of range (#{column} for 1..#{@column})!"
+        end
+        @line.times do |line|
+          col << self[line+1, column]
+        end
+
+        return col
+      end
+
+      def transpose
+        matrix = GraphViz::Math::Matrix.new( @column, @line )
+        @line.times do |line|
+          @column.times do |column|
+            matrix[column+1, line+1] = self[line+1, column+1]
+          end
+        end
+        return matrix
+      end
+
+      def ==(m)
+        equal = true
+        @line.times do |line|
+          @column.times do |column|
+            equal &&= (m[line+1, column+1] == self[line+1, column+1])
+          end
+        end
+        return equal
+      end
+
+      def remove_line(n)
+        unless (0...@line).to_a.include?(n-1)
+          raise CoordinateError, "Line out of range (#{n} for 1..#{@line})!"
+        end
+
+        matrix = GraphViz::Math::Matrix.new( @line - 1, @column )
+        nline = 0
+        @line.times do |line|
+          next if line == n - 1
+          @column.times do |column|
+            matrix[nline+1, column+1] = self[line+1, column+1]
+          end
+          nline += 1
+        end
+        return matrix
+      end
+
+      def remove_column(n)
+        unless (0...@column).to_a.include?(n-1)
+          raise CoordinateError, "Column out of range (#{n} for 1..#{@column})!"
+        end
+
+        matrix = GraphViz::Math::Matrix.new( @line, @column - 1 )
+        @line.times do |line|
+          ncolumn = 0
+          @column.times do |column|
+            next if column == n - 1
+            matrix[line+1, ncolumn+1] = self[line+1, column+1]
+            ncolumn += 1
+          end
+        end
+        return matrix
+      end
+
+      def sum_of_column(n)
+        column(n).inject(0){|sum,item| sum + item}
+      end
+
+      def sum_of_line(n)
+        line(n).inject(0){|sum,item| sum + item}
+      end
+
+      def set_matrix(m) #:nodoc:
+        @matrix = m
+      end
+
+      private
+      def bigger
+        b = 0
+        @matrix.each do |line|
+          line.each do |column|
+            b = column.to_s.size if column.to_s.size > b
+          end
+        end
+        return b
+      end
+    end
+  end
+end