ruby-graphviz_c 1.1.0

data/lib/graphviz/dsl.rb

@@ -0,0 +1,67 @@
+require 'graphviz'
+
+class GraphViz::DSL
+   attr_accessor :graph
+
+   # Create a new graph
+   def initialize(name, options = {}, &block)
+      @graph = GraphViz.new(name, options)
+      instance_eval(&block) if block
+   end
+
+   def method_missing(sym, *args, &block) #:nodoc:
+      return @graph.get_graph(sym.to_s) unless @graph.get_graph(sym.to_s).nil?
+      return @graph.get_node(sym.to_s) unless @graph.get_node(sym.to_s).nil?
+      if(@graph.respond_to?(sym, true))
+         @graph.send(sym, *args)
+      elsif(block)
+         @graph.add_graph(GraphViz::DSL.new(sym, { :parent => @graph, :type => @graph.type }, &block).graph)
+      else
+         @graph.add_nodes(sym.to_s, *args)
+      end
+   end
+
+   # Add a new node
+   def n(name)
+      return @graph.get_node(name) unless @graph.get_node(name.to_s).nil?
+      @graph.add_nodes(name)
+   end
+
+   # Create edges
+   def e(*args)
+      e = nil
+      last = args.shift
+      while current = args.shift
+         e = @graph.add_edges(last, current)
+         last = current
+      end
+      return e
+   end
+
+   # Add a subgraph
+   def subgraph(name, &block)
+      @graph.add_graph(GraphViz::DSL.new(name, { :parent => @graph, :type => @graph.type }, &block).graph)
+   end
+   alias :cluster :subgraph
+
+   # Generate output
+   def output(options = {})
+      @graph.output(options)
+   end
+end
+
+# Create a new undirected graph
+def graph(name, options = {}, &block)
+   GraphViz::DSL.new(name, options.merge( { :type => "graph" } ), &block).graph
+end
+
+# Create a new directed graph
+def digraph(name, options = {}, &block)
+   GraphViz::DSL.new(name, options.merge( { :type => "digraph" } ), &block).graph
+end
+
+# Create a new strict directed graph
+def strict(name, options = {}, &block)
+   GraphViz::DSL.new(name, options.merge( { :type => "strict digraph" } ), &block).graph
+end
+

data/lib/graphviz/edge.rb

@@ -0,0 +1,197 @@
+# Copyright (C) 2004 - 2012 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 Edge
+      include GraphViz::Constants
+
+      # Create a new edge
+      #
+      # In:
+      # * vNodeOne : First node (can be a GraphViz::Node or a node ID)
+      # * vNodeTwo : Second node (can be a GraphViz::Node or a node ID)
+      # * parent_graph : Graph
+      def initialize( vNodeOne, vNodeTwo, parent_graph )
+         @node_one_id, @node_one_port = getNodeNameAndPort( vNodeOne )
+         @node_two_id, @node_two_port = getNodeNameAndPort( vNodeTwo )
+
+         @parent_graph = parent_graph
+         @edge_attributes = GraphViz::Attrs::new( nil, "edge", EDGESATTRS )
+         @index = nil
+
+         unless @parent_graph.directed?
+            (@parent_graph.find_node(@node_one_id) || @parent_graph.add_nodes(@node_one_id)).incidents << (@parent_graph.find_node(@node_two_id) || @parent_graph.add_nodes(@node_two_id))
+            (@parent_graph.find_node(@node_two_id) || @parent_graph.add_nodes(@node_two_id)).neighbors << (@parent_graph.find_node(@node_one_id) || @parent_graph.add_nodes(@node_one_id))
+         end
+         (@parent_graph.find_node(@node_one_id) || @parent_graph.add_nodes(@node_one_id)).neighbors << (@parent_graph.find_node(@node_two_id) || @parent_graph.add_nodes(@node_two_id))
+         (@parent_graph.find_node(@node_two_id) || @parent_graph.add_nodes(@node_two_id)).incidents << (@parent_graph.find_node(@node_one_id) || @parent_graph.add_nodes(@node_one_id))
+      end
+
+      # Return the node one as string (so with port if any)
+      def node_one( with_port = true )
+         if not(@node_one_port and with_port)
+            GraphViz.escape(@node_one_id)
+         else
+            GraphViz.escape(@node_one_id, :force => true) + ":#{@node_one_port}"
+         end
+      end
+      alias :tail_node :node_one
+
+      # Return the node two as string (so with port if any)
+      def node_two( with_port = true )
+         if not(@node_two_port and with_port)
+            GraphViz.escape(@node_two_id)
+         else
+            GraphViz.escape(@node_two_id, :force => true) + ":#{@node_two_port}"
+         end
+      end
+      alias :head_node :node_two
+
+      # Return the index of the edge
+      def index
+         @index
+      end
+      def index=(i) #:nodoc:
+         @index = i if @index == nil
+      end
+
+      # Set value +attribute_value+ to the edge attribute +attribute_name+
+      def []=( attribute_name, attribute_value )
+         attribute_value = attribute_value.to_s if attribute_value.class == Symbol
+         @edge_attributes[attribute_name.to_s] = attribute_value
+      end
+
+      # Set values for edge attributes or
+      # get the value of the given edge attribute +attribute_name+
+      def []( attribute_name )
+         # Modification by axgle (http://github.com/axgle)
+         if Hash === attribute_name
+            attribute_name.each do |key, value|
+               self[key] = value
+            end
+         else
+            if @edge_attributes[attribute_name.to_s]
+               @edge_attributes[attribute_name.to_s].clone
+            else
+               nil
+            end
+         end
+      end
+
+      #
+      # Calls block once for each attribute of the edge, passing the name and value to the
+      # block as a two-element array.
+      #
+      # If global is set to false, the block does not receive the attributes set globally
+      #
+      def each_attribute(global = true, &b)
+         attrs = @edge_attributes.to_h
+         if global
+            attrs = pg.edge.to_h.merge attrs
+         end
+         attrs.each do |k,v|
+            yield(k,v)
+         end
+      end
+      def each_attribut(global = true, &b)
+         warn "`GraphViz::Edge#each_attribut` is deprecated, please use `GraphViz::Edge#each_attribute`"
+         each_attribute(global, &b)
+      end
+
+      def <<( node ) #:nodoc:
+         n = @parent_graph.get_node(@node_two_id)
+
+         GraphViz::commonGraph( node, n ).add_edges( n, node )
+      end
+      alias :> :<< #:nodoc:
+      alias :- :<< #:nodoc:
+      alias :>> :<< #:nodoc:
+
+      #
+      # Return the root graph
+      #
+      def root_graph
+         return( (self.pg.nil?) ? nil : self.pg.root_graph )
+      end
+
+      def pg #:nodoc:
+         @parent_graph
+      end
+
+      # Set edge attributes
+      #
+      # Example :
+      #   e = graph.add_edges( ... )
+      #   ...
+      #   e.set { |_e|
+      #     _e.color = "blue"
+      #     _e.fontcolor = "red"
+      #   }
+      def set( &b )
+         yield( self )
+      end
+
+      # 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]
+      end
+
+      def output( oGraphType ) #:nodoc:
+         xLink = " -> "
+         if oGraphType == "graph"
+            xLink = " -- "
+         end
+
+         xOut = self.node_one + xLink + self.node_two
+         xAttr = ""
+         xSeparator = ""
+         @edge_attributes.data.each do |k, v|
+            xAttr << xSeparator + k + " = " + v.to_gv
+            xSeparator = ", "
+         end
+         if xAttr.length > 0
+            xOut << " [" + xAttr + "]"
+         end
+         xOut << ";"
+
+         return( xOut )
+      end
+
+      private
+      def getNodeNameAndPort( node )
+         name, port = nil, nil
+         if node.class == Hash
+            node.each do |k, v|
+               name, port = getNodeNameAndPort(k)
+               port = v
+            end
+         elsif node.class == String
+            name = node
+         else
+            name = node.id
+         end
+
+         return name, port
+      end
+   end
+end

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/ext.rb

@@ -0,0 +1,17 @@
+require 'find'
+
+class GraphViz
+  class Ext
+    def self.find( ext = nil )
+      myPath = File.join( File.dirname( File.expand_path( __FILE__ ) ), "..", "ext" )
+      found = myPath
+      unless ext.nil?
+        Find.find(myPath) do |path|
+          found = path if File.basename( path ) == ext
+        end
+      end
+
+      File.expand_path( found )
+    end
+  end
+end

data/lib/graphviz/family_tree/couple.rb

@@ -0,0 +1,63 @@
+class GraphViz
+  class FamilyTree
+    class Couple
+      def initialize( graph, node, persons ) #:nodoc:
+        @graph = graph
+        @node = node
+        @kids = []
+        @persons = persons
+      end
+
+      def node #:nodoc:
+        @node
+      end
+
+      # Add kids to a couple
+      def kids( *z )
+        @kids = GraphViz::FamilyTree::Sibling.new( z, @persons )
+
+        return
+
+        if z.size == 1
+          @graph.add_edges( @node, z[0].node, "dir" => "none" )
+        else
+          cluster = @graph.add_graph( "#{@node.id}Kids" )
+          cluster["rank"] = "same"
+
+          last = nil
+          count = 0
+          add = (z.size-1)%2 * z.size/2 + (z.size-1)%2
+          link = (z.size/2)+1
+
+          z.each do |person|
+            count = count + 1
+            if count == add
+              middle = cluster.add_nodes( "#{@node.id}Kids", "shape" => "point" )
+              @graph.add_edges( @node, middle, "dir" => "none" )
+              unless last.nil?
+                cluster.add_edges( last, middle, "dir" => "none" )
+              end
+              last = middle
+            end
+
+            kid = cluster.add_nodes( "#{person.node.id}Kid", "shape" => "point" )
+            @graph.add_edges( kid, person.node, "dir" => "none" )
+
+            if add == 0 and count == link
+              @graph.add_edges( @node, kid, "dir" => "none" )
+            end
+
+            unless last.nil?
+              cluster.add_edges( last, kid, "dir" => "none" )
+            end
+            last = kid
+          end
+        end
+      end
+
+      def getKids
+        @kids
+      end
+    end
+  end
+end

data/lib/graphviz/family_tree/generation.rb

@@ -0,0 +1,39 @@
+class GraphViz
+  class FamilyTree
+    class Generation
+      def initialize( graph, persons, tree, gen_number ) #:nodoc:
+        @graph = graph
+        @all_persons = persons
+        @persons = {}
+        @tree = tree
+        @gen_number = gen_number
+      end
+
+      def all_persons #:nodoc:
+        @all_persons
+      end
+
+      def persons
+        @persons
+      end
+
+      def make( &block ) #:nodoc:
+        instance_eval(&block) if block
+      end
+
+      def method_missing(sym, *args, &block) #:nodoc:
+        all_persons[sym.to_s] ||= (persons[sym.to_s] ||= GraphViz::FamilyTree::Person.new( @graph, @tree, self, sym.to_s ))
+      end
+
+      # Generation number
+      def number
+        @gen_number
+      end
+
+      # Generation size
+      def size
+        @persons.size
+      end
+    end
+  end
+end

data/lib/graphviz/family_tree/person.rb

@@ -0,0 +1,120 @@
+require 'rubygems'
+require 'graphviz'
+
+class GraphViz
+  class FamilyTree
+    class Person
+      def initialize( graph, tree, generation, id ) #:nodoc:
+        @graph = graph
+        @node = @graph.add_nodes( id )
+        @node["shape"] = "box"
+        @tree = tree
+        @generation = generation
+        @x, @y = 0, 0
+        @sibling = nil
+      end
+
+      def id
+        @node.id
+      end
+
+      def name
+        @node.label || @node.id
+      end
+
+      def sibling
+        @sibling
+      end
+
+      def sibling=(x)
+        @sibling=x
+      end
+
+      def couples #:nodoc:
+        @couples
+      end
+
+      def node #:nodoc:
+        @node
+      end
+
+      # Define the current person as a man
+      #
+      #  greg.is_a_man( "Greg" )
+      def is_a_man( name )
+        @node["label"] = name
+        @node["color"] = "blue"
+      end
+
+      # Define the current person as a boy
+      #
+      #  greg.is_a_boy( "Greg" )
+      def is_a_boy( name )
+        is_a_man( name )
+      end
+
+      # Define the current perdon as a woman
+      #
+      #  mu.is_a_woman( "Muriel" )
+      def is_a_woman( name )
+        @node["label"] = name
+        @node["color"] = "pink"
+      end
+      # Define the current perdon as a girl
+      #
+      #  maia.is_a_girl( "Maia" )
+      def is_a_girl( name )
+        is_a_woman( name )
+      end
+
+      # Define that's two persons are maried
+      #
+      #  mu.is_maried_with greg
+      def is_maried_with( x )
+        node = @graph.add_nodes( "#{@node.id}And#{x.node.id}" )
+        node["shape"] = "point"
+        @graph.add_edges( @node, node, "dir" => "none" )
+        @graph.add_edges( node, x.node, "dir" => "none" )
+        @tree.add_couple( self, x, node )
+      end
+
+      # Define that's two persons are divorced
+      #
+      #  sophie.is_divorced_with john
+      def is_divorced_with( x )
+        node = @graph.add_nodes( "#{@node.id}And#{x.node.id}" )
+        node["shape"] = "point"
+        node["color"] = "red"
+        @graph.add_edges( @node, node, "dir" => "none", "color" => "red" )
+        @graph.add_edges( node, x.node, "dir" => "none", "color" => "red" )
+        @tree.add_couple( self, x, node )
+      end
+
+      # Define that's a person is widower of another
+      #
+      #  simon.is_widower_of elisa
+      def is_widower_of( x ) #veuf
+        node = @graph.add_nodes( "#{@node.id}And#{x.node.id}" )
+        node["shape"] = "point"
+        node["color"] = "green"
+        @graph.add_edges( @node, node, "dir" => "none", "color" => "green" )
+        @graph.add_edges( node, x.node, "dir" => "none", "color" => "green" )
+        @tree.add_couple( self, x, node )
+      end
+
+      # Define the current person as dead
+      #
+      #  jack.is_dead
+      def is_dead
+        @node["style"] = "filled"
+      end
+
+      # Define the kids of a single person
+      #
+      #   alice.kids( john, jack, julie )
+      def kids( *z )
+        GraphViz::FamilyTree::Couple.new( @graph, @node, [self] ).kids( *z )
+      end
+    end
+  end
+end