ruby-graphviz_c 1.1.0

data/lib/graphviz/constants.rb

@@ -0,0 +1,294 @@
+# 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
+
+# Constants for ruby-graphviz
+#
+# GraphViz::Constants::FORMATS: the possible output formats
+#   "bmp", "canon", "dot", "xdot", "cmap", "dia", "eps",
+#   "fig", "gd", "gd2", "gif", "gtk", "hpgl", "ico", "imap",
+#   "cmapx", "imap_np", "cmapx_np", "ismap", "jpeg", "jpg",
+#   "jpe", "mif", "mp", "pcl", "pdf", "pic", "plain",
+#   "plain-ext", "png", "ps", "ps2", "svg", "svgz", "tga",
+#   "tiff", "tif", "vml", "vmlz", "vrml", "vtx", "wbmp",
+#   "xlib", "none"
+#
+# GraphViz::Constants::PROGRAMS: The possible programs
+#   "dot", "neato", "twopi", "fdp", "circo"
+#
+# GraphViz::Constants::GRAPHTYPE The possible types of graph
+#   "digraph", "graph"
+#
+#
+# The single letter codes used in constructors map as follows:
+#   G => The root graph, with GRAPHATTRS
+#   E => Edge, with EDGESATTRS
+#   N => Node, with NODESATTRS
+#   S => subgraph
+#   C => cluster
+#
+class GraphViz
+  module Constants
+    RGV_VERSION = "1.1.0"
+
+    ## Const: Output formats
+    FORMATS = [
+      "bmp",
+      "canon",
+      "dot",
+      "xdot",
+      "cmap",
+      "dia",
+      "eps",
+      "fig",
+      "gd",
+      "gd2",
+      "gif",
+      "gtk",
+      "hpgl",
+      "ico",
+      "imap",
+      "cmapx",
+      "imap_np",
+      "cmapx_np",
+      "ismap",
+      "jpeg",
+      "jpg",
+      "jpe",
+      "mif",
+      "mp",
+      "pcl",
+      "pdf",
+      "pic",
+      "plain",
+      "plain-ext",
+      "png",
+      "ps",
+      "ps2",
+      "svg",
+      "svgz",
+      "tga",
+      "tiff",
+      "tif",
+      "vml",
+      "vmlz",
+      "vrml",
+      "vtx",
+      "wbmp",
+      "xlib",
+      "none"
+    ]
+
+    ## Const: programs
+    PROGRAMS = [
+      "dot",
+      "neato",
+      "twopi",
+      "fdp",
+      "circo",
+      "sfdp"
+    ]
+
+    ## Const: graphs type
+    GRAPHTYPE = [
+      "digraph",
+      "graph",
+      "strict digraph"
+    ]
+
+    def self.getAttrsFor( x )
+      list = {}
+      GENCS_ATTRS.each { |k,v|
+        list[k] = v[:type] if x.match( v[:usedBy] ) and not list.keys.include?(k)
+      }
+      list
+    end
+
+    # E, N, G, S and C represent edges, nodes, the root graph, subgraphs and cluster subgraphs, respectively
+    GENCS_ATTRS = {
+      "Damping"             => { :usedBy => "G",    :type => :GvDouble },
+      "K"                   => { :usedBy => "GC",   :type => :GvDouble },
+      "URL"                 => { :usedBy => "ENGC", :type => :EscString },
+      "area"                => { :usedBy => "NC",   :type => :GvDouble },
+      "arrowhead"           => { :usedBy => "E",    :type => :ArrowType }, # arrowType
+      "arrowsize"           => { :usedBy => "E",    :type => :GvDouble },
+      "arrowtail"           => { :usedBy => "E",    :type => :ArrowType }, # arrowType
+      "aspect"              => { :usedBy => "G",    :type => :EscString }, # aspectType
+      "bb"                  => { :usedBy => "G",    :type => :Rect }, # rect
+      "bgcolor"             => { :usedBy => "GC",   :type => :Color }, # color
+      "center"              => { :usedBy => "G",    :type => :GvBool },    # bool
+      "charset"             => { :usedBy => "G",    :type => :EscString }, # string
+      "clusterrank"         => { :usedBy => "G",    :type => :EscString }, # clusterMode
+      "color"               => { :usedBy => "ENC",  :type => :ColorList }, # color, colorList
+      "colorscheme"         => { :usedBy => "ENCG", :type => :EscString }, # string
+      "comment"             => { :usedBy => "ENG",  :type => :EscString }, # string
+      "compound"            => { :usedBy => "G",    :type => :GvBool },    # bool
+      "concentrate"         => { :usedBy => "G",    :type => :GvBool },    # bool
+      "constraint"          => { :usedBy => "E",    :type => :GvBool },    # bool
+      "decorate"            => { :usedBy => "E",    :type => :GvBool },    # bool
+      "defaultdist"         => { :usedBy => "G",    :type => :GvDouble },
+      "dim"                 => { :usedBy => "G",    :type => :EscString }, # int
+      "dimen"               => { :usedBy => "G",    :type => :EscString }, # int
+      "dir"                 => { :usedBy => "E",    :type => :EscString }, # dirType
+      "diredgeconstraints"  => { :usedBy => "G",    :type => :EscString }, # string, bool
+      "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 => :GvDouble },
+      "esep"                => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
+      "fillcolor"           => { :usedBy => "NEC",  :type => :Color }, # color
+      "fixedsize"           => { :usedBy => "N",    :type => :GvBool }, # bool
+      "fontcolor"           => { :usedBy => "ENGC", :type => :Color }, # color
+      "fontname"            => { :usedBy => "ENGC", :type => :EscString }, # string
+      "fontnames"           => { :usedBy => "G",    :type => :EscString }, # string
+      "fontpath"            => { :usedBy => "G",    :type => :EscString }, # string
+      "fontsize"            => { :usedBy => "ENGC", :type => :GvDouble },
+      "forcelabels"         => { :usedBy => "G",    :type => :GvBool}, # bool
+      "gradientangle"       => { :usedBy => "NCG",  :type => :EscString }, # int
+      "group"               => { :usedBy => "N",    :type => :EscString }, # string
+      "headURL"             => { :usedBy => "E",    :type => :EscString },
+      "headclip"            => { :usedBy => "E",    :type => :GvBool }, # bool
+      "headhref"            => { :usedBy => "E",    :type => :EscString },
+      "headlabel"           => { :usedBy => "E",    :type => :EscString }, # LblString
+      "headport"            => { :usedBy => "E",    :type => :EscString }, # portPos
+      "headtarget"          => { :usedBy => "E",    :type => :EscString },
+      "headtooltip"         => { :usedBy => "E",    :type => :EscString },
+      "height"              => { :usedBy => "N",    :type => :GvDouble },
+      "href"                => { :usedBy => "ENGC", :type => :EscString },
+      "id"                  => { :usedBy => "ENG",  :type => :EscString },
+      "image"               => { :usedBy => "N",    :type => :EscString }, # string
+      "imagepath"           => { :usedBy => "G",    :type => :EscString }, # string
+      "imagescale"          => { :usedBy => "N",    :type => :EscString }, # bool, string
+      "label"               => { :usedBy => "ENGC", :type => :LblString },
+      "labelURL"            => { :usedBy => "E",    :type => :EscString },
+      "label_scheme"        => { :usedBy => "G",    :type => :EscString }, # int
+      "labelangle"          => { :usedBy => "E",    :type => :GvDouble },
+      "labeldistance"       => { :usedBy => "E",    :type => :GvDouble },
+      "labelfloat"          => { :usedBy => "E",    :type => :GvBool }, # bool
+      "labelfontcolor"      => { :usedBy => "E",    :type => :Color }, # color
+      "labelfontname"       => { :usedBy => "E",    :type => :EscString }, # string
+      "labelfontsize"       => { :usedBy => "E",    :type => :GvDouble },
+      "labelhref"           => { :usedBy => "E",    :type => :EscString },
+      "labeljust"           => { :usedBy => "GC",   :type => :EscString }, # string
+      "labelloc"            => { :usedBy => "GCN",  :type => :EscString }, # string
+      "labeltarget"         => { :usedBy => "E",    :type => :EscString },
+      "labeltooltip"        => { :usedBy => "E",    :type => :EscString },
+      "landscape"           => { :usedBy => "G",    :type => :GvBool }, # bool
+      "layer"               => { :usedBy => "ENC",  :type => :EscString }, # layerRange
+      "layerlistsep"        => { :usedBy => "G",    :type => :EscString }, # string
+      "layers"              => { :usedBy => "G",    :type => :EscString }, # layerList
+      "layerselect"         => { :usedBy => "G",    :type => :EscString }, # layerRange
+      "layersep"            => { :usedBy => "G",    :type => :EscString }, # string
+      "layout"              => { :usedBy => "G",    :type => :EscString }, # string
+      "len"                 => { :usedBy => "E",    :type => :GvDouble },
+      "levels"              => { :usedBy => "G",    :type => :EscString }, # int
+      "levelsgap"           => { :usedBy => "G",    :type => :GvDouble },
+      "lhead"               => { :usedBy => "E",    :type => :EscString }, # string
+      "lheight"             => { :usedBy => "GC",   :type => :GvDouble },
+      "lp"                  => { :usedBy => "EGC",  :type => :EscString }, # point
+      "ltail"               => { :usedBy => "E",    :type => :EscString }, # string
+      "lwidth"              => { :usedBy => "GC",   :type => :GvDouble },
+      "margin"              => { :usedBy => "NGC",  :type => :EscString }, # GvDouble , pointf
+      "maxiter"             => { :usedBy => "G",    :type => :EscString }, # int
+      "mclimit"             => { :usedBy => "G",    :type => :GvDouble },
+      "mindist"             => { :usedBy => "G",    :type => :GvDouble },
+      "minlen"              => { :usedBy => "E",    :type => :EscString }, # int
+      "mode"                => { :usedBy => "G",    :type => :EscString }, # string
+      "model"               => { :usedBy => "G",    :type => :EscString }, # string
+      "mosek"               => { :usedBy => "G",    :type => :GvBool }, # bool
+      "nodesep"             => { :usedBy => "G",    :type => :GvDouble },
+      "nojustify"           => { :usedBy => "GCNE", :type => :GvBool }, # bool
+      "normalize"           => { :usedBy => "G",    :type => :GvBool }, # bool
+      "nslimit"             => { :usedBy => "G",    :type => :GvDouble },
+      "nslimit1"            => { :usedBy => "G",    :type => :GvDouble },
+      "ordering"            => { :usedBy => "GN",   :type => :EscString }, # string
+      "orientation"         => { :usedBy => "NG",   :type => :GvDouble },  # N: double, G: string
+      "outputorder"         => { :usedBy => "G",    :type => :EscString }, # outputMode
+      "overlap"             => { :usedBy => "G",    :type => :EscString }, # string, bool
+      "overlap_scaling"     => { :usedBy => "G",    :type => :GvDouble },
+      "pack"                => { :usedBy => "G",    :type => :EscString }, # bool, int
+      "packmode"            => { :usedBy => "G",    :type => :EscString }, # packMode
+      "pad"                 => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
+      "page"                => { :usedBy => "G",    :type => :EscString }, # GvDouble , pointf
+      "pagedir"             => { :usedBy => "G",    :type => :EscString }, # pageDir
+      "pencolor"            => { :usedBy => "C",    :type => :Color }, # color
+      "penwidth"            => { :usedBy => "CNE",  :type => :GvDouble },
+      "peripheries"         => { :usedBy => "NC",   :type => :EscString }, # int
+      "pin"                 => { :usedBy => "N",    :type => :GvBool }, # bool
+      "pos"                 => { :usedBy => "EN",   :type => :SplineType }, # point, splineTypes
+      "quadtree"            => { :usedBy => "G",    :type => :GvBool }, # bool
+      "quantum"             => { :usedBy => "G",    :type => :GvDouble },
+      "rank"                => { :usedBy => "S",    :type => :EscString }, # rankType
+      "rankdir"             => { :usedBy => "G",    :type => :EscString }, # rankDir
+      "ranksep"             => { :usedBy => "G",    :type => :EscString }, # GvDouble, doubleList
+      "ratio"               => { :usedBy => "G",    :type => :EscString }, # GvDouble, String
+      "rects"               => { :usedBy => "N",    :type => :Rect }, # rect
+      "regular"             => { :usedBy => "N",    :type => :GvBool }, # bool
+      "remincross"          => { :usedBy => "G",    :type => :GvBool }, # bool
+      "repulsiveforce"      => { :usedBy => "G",    :type => :GvDouble },
+      "resolution"          => { :usedBy => "G",    :type => :GvDouble },
+      "root"                => { :usedBy => "GN",   :type => :EscString }, # bool, string
+      "rotate"              => { :usedBy => "G",    :type => :EscString }, # int
+      "rotation"            => { :usedBy => "G",    :type => :GvDouble },
+      "samehead"            => { :usedBy => "E",    :type => :EscString }, # string
+      "sametail"            => { :usedBy => "E",    :type => :EscString }, # string
+      "samplepoints"        => { :usedBy => "G",    :type => :EscString }, # int
+      "scale"               => { :usedBy => "G",    :type => :EscString }, # double, pointf
+      "searchsize"          => { :usedBy => "G",    :type => :EscString }, # int
+      "sep"                 => { :usedBy => "G",    :type => :EscString }, # double , pointf
+      "shape"               => { :usedBy => "N",    :type => :EscString }, # shape
+      "shapefile"           => { :usedBy => "N",    :type => :EscString }, # string
+      "showboxes"           => { :usedBy => "ENG",  :type => :EscString }, # int
+      "sides"               => { :usedBy => "N",    :type => :EscString }, # int
+      "size"                => { :usedBy => "NG",   :type => :EscString }, # double , pointf
+      "skew"                => { :usedBy => "N",    :type => :GvDouble },
+      "smoothing"           => { :usedBy => "G",    :type => :EscString }, # smoothType
+      "sortv"               => { :usedBy => "GCN",  :type => :EscString }, # int
+      "splines"             => { :usedBy => "G",    :type => :EscString }, # bool, string
+      "start"               => { :usedBy => "G",    :type => :EscString }, # startType
+      "style"               => { :usedBy => "ENCG", :type => :EscString }, # style
+      "stylesheet"          => { :usedBy => "G",    :type => :EscString }, # string
+      "tailURL"             => { :usedBy => "E",    :type => :EscString },
+      "tailclip"            => { :usedBy => "E",    :type => :GvBool }, # bool
+      "tailhref"            => { :usedBy => "E",    :type => :EscString },
+      "taillabel"           => { :usedBy => "E",    :type => :EscString }, # lblString
+      "tailport"            => { :usedBy => "E",    :type => :EscString }, # portPos
+      "tailtarget"          => { :usedBy => "E",    :type => :EscString },
+      "tailtooltip"         => { :usedBy => "E",    :type => :EscString },
+      "target"              => { :usedBy => "ENGC", :type => :EscString }, # escString, string
+      "tooltip"             => { :usedBy => "NEC",  :type => :EscString },
+      "truecolor"           => { :usedBy => "G",    :type => :GvBool }, # bool
+      "vertices"            => { :usedBy => "N",    :type => :EscString }, # pointfList
+      "viewport"            => { :usedBy => "G",    :type => :EscString }, # viewPort
+      "voro_margin"         => { :usedBy => "G",    :type => :GvDouble },
+      "weight"              => { :usedBy => "E",    :type => :GvDouble },
+      "width"               => { :usedBy => "N",    :type => :GvDouble },
+      "xlabel"              => { :usedBy => "EN",   :type => :LblString },
+      "z"                   => { :usedBy => "N",    :type => :GvDouble }
+    }
+
+    ## Const: Graph attributes
+    GRAPHSATTRS = GraphViz::Constants::getAttrsFor( /G|S|C/ )
+
+    ## Const: Node attributes
+    NODESATTRS = GraphViz::Constants::getAttrsFor( /N/ )
+
+    ## Const: Edge attributes
+    EDGESATTRS = GraphViz::Constants::getAttrsFor( /E/ )
+  end
+end

data/lib/graphviz/core_ext.rb

@@ -0,0 +1,64 @@
+class String
+   def self.random(size)
+      s = ""
+      d = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+      size.times {
+         s << d[rand(d.size)]
+      }
+      return s
+   end
+
+   def convert_base(from, to)
+      self.to_i(from).to_s(to)
+   end
+end
+
+class Object
+   def to_ruby
+      begin
+         eval self
+      rescue
+         self
+      end
+   end
+end
+
+# From : http://www.geekmade.co.uk/2008/09/ruby-tip-normalizing-hash-keys-as-symbols/
+class Hash
+   def symbolize_keys
+      inject({}) do |options, (key, value)|
+         options[(key.to_sym rescue key) || key] = value
+      options
+      end
+   end
+
+   # x = {
+   #   :none => String,
+   #   :png => "file.png",
+   #   :svg => "file.svg"
+   # }
+   #
+   # x.each_except( :key => [:none], :value => [/\.png$/] ) do |k, v|
+   #   puts "#{k} -> #{v}"
+   # end
+   #
+   # => svg -> file.svg
+   def each_except( e, &b )
+      key_table = (e[:key]||[]).clone.delete_if {|i| i.kind_of? Regexp }
+      key_regexp = (e[:key]||[]).clone.delete_if {|i| key_table.include? i }.map {|i| i.to_s }.join("|")
+
+      value_table = (e[:value]||[]).clone.delete_if {|i| i.kind_of? Regexp }
+      value_regexp = (e[:value]||[]).clone.delete_if {|i| value_table.include? i }.map {|i| i.to_s }.join("|")
+
+      self.each do |k, v|
+         yield( k, v ) unless (key_table.size > 0 and key_table.include?(k)) or (key_regexp.size > 0 and k.to_s.match(key_regexp)) or (value_table.size > 0 and value_table.include?(v)) or (value_regexp.size > 0 and v.to_s.match(value_regexp))
+      end
+   end
+
+   unless self.method_defined? :key
+      # Add Hash#key to Ruby < 1.9
+      def key(v)
+         index(v)
+      end
+   end
+end

data/lib/graphviz/dot2ruby.rb

@@ -0,0 +1,59 @@
+#!/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/ext'
+require 'graphviz/utils'
+
+class Dot2Ruby #:nodoc:
+  include GraphViz::Utils
+
+  def initialize( xGVPath, xOutFile, xOutFormat = nil ) #:nodoc:
+    paths = (xGVPath.nil?) ? [] : [xGVPath]
+    @xGvprPath = find_executable( 'gvpr', paths )
+    @xOutFile = xOutFile
+    @xOutFormat = xOutFormat || "_"
+    @gvprScript = GraphViz::Ext.find( "dot2ruby.g" )
+  end
+
+  def run( xFile ) #:nodoc:
+    xCmd = [@xGvprPath, '-f', @gvprScript, '-a', @xOutFormat, xFile]
+    xOutput = output_from_command( xCmd )
+    if @xOutFile.nil?
+      puts xOutput
+    else
+      File.open( @xOutFile, "w" ) do |io|
+        io.print xOutput
+      end
+    end
+  end
+
+  def eval( xFile ) #:nodoc:
+    xCmd = [@xGvprPath, '-f', @gvprScript, '-a', '-', xFile]
+    xOutput = output_from_command( xCmd )
+    instance_eval(xOutput)
+    return @_graph_eval
+  end
+
+  def eval_string( data ) #:nodoc:
+    t = Tempfile::open( File.basename(__FILE__) )
+    t.print( data )
+    t.close
+    result = self.eval(t.path)
+    t.close
+    return result
+  end
+end

data/lib/graphviz/dot_script.rb

@@ -0,0 +1,109 @@
+require "forwardable"
+class GraphViz
+
+  class DOTScriptData
+    attr_accessor :type
+    def initialize(type = nil)
+      @data = []
+      @separator = ""
+      @type = type
+    end
+
+    def append(data)
+      @data << data
+    end
+    alias :<< :append
+
+    def add_attribute(name, value)
+      @data << @separator << name << " = " << value
+      @separator = determine_separator
+    end
+
+    def to_str
+      case @type
+        when "graph_attr" then "#{@data.join}#{@separator}"
+        when "node_attr" then "node[#{@data.join(' ')}];"
+        when "edge_attr" then "edge[#{@data.join(' ')}];"
+        else raise ArgumentError, "Wrong type: #{@type}."
+      end
+    end
+    alias :to_s :to_str
+
+    def empty?
+      @data.empty?
+    end
+
+    private
+
+    def determine_separator
+      case @type
+        when "graph_attr"             then ";\n"
+        when "node_attr", "edge_attr" then ","
+        else raise ArgumentError, "Wrong type: #{@type}."
+      end
+    end
+
+  end
+
+  class DOTScript
+    extend Forwardable
+
+    def_delegators :@script, :end_with?
+
+    def initialize
+      @script = ''
+    end
+
+    def append(line)
+      @script << assure_ends_with(line.to_s,"\n")
+
+      self
+    end
+    alias :<< :append
+
+    def prepend(line)
+      @script = assure_ends_with(line.to_s,"\n") + @script
+
+      self
+    end
+
+    def make_subgraph(name)
+      prepend(assure_ends_with("subgraph #{name}"," {"))
+    end
+
+    def add_type(type, data)
+      return self if data.empty?
+
+      case type
+      when "graph_attr"
+        append_statement("  " + data)
+      when "node_attr"
+        append_statement("  node [" + data + "]")
+      when "edge_attr"
+        append_statement("  edge [" + data + "]")
+      else
+        raise ArgumentError,
+          "Unknown type: #{type}." <<
+          "Possible: 'graph_attr','node_attr','edge_attr'"
+      end
+
+      self
+    end
+
+    def to_str
+      @script
+    end
+    alias :to_s :to_str
+
+    private
+
+    def assure_ends_with(str,ending="\n")
+      str.to_s.end_with?("\n") ? str : str + ending
+    end
+
+    def append_statement(statement)
+      append(assure_ends_with(statement, ";\n"))
+    end
+
+  end
+end