rgl 0.2.2 → 0.2.3

data/lib/rgl/implicit.rb

@@ -1,151 +1,174 @@
-# This file contains the definition of the class RGL::ImplicitGraph which
+# implicit.rb 
+#
+# This file contains the definition of the class RGL::ImplicitGraph, which
 # defines vertex and edge iterators using blocks (which again call blocks).
 # 
-# An ImplicitGraph provides a handy way to define graphs on the fly using two
-# blocks for the two iterators defining a graph. The directed cyclic graph with
-# 5 vertices can be created as follows:
+# An ImplicitGraph provides a handy way to define graphs on the fly, using two
+# blocks for the two iterators defining a graph.  A directed cyclic graph,
+# with five vertices can be created as follows:
 #
 #   g = RGL::ImplicitGraph.new { |g|
-# 	  g.vertex_iterator { |b| 0.upto(4,&b) }
-# 	  g.adjacent_iterator { |x, b| b.call((x+1)%5) }
-# 	  g.directed = true
+#     g.vertex_iterator { |b| 0.upto(4,&b) }
+#     g.adjacent_iterator { |x, b| b.call((x+1)%5) }
+#     g.directed = true
 #   }
+#
 #   g.to_s => "(0-1)(1-2)(2-3)(3-4)(4-0)"
 #
 # Other examples are given by the methods vertices_filtered_by and
 # edges_filtered_by, which can be applied to any graph.
+
 require 'rgl/base'
 
 module RGL
+
   class ImplicitGraph
-	include Graph
-
-	attr_writer :directed
-
-	EMPTY_VERTEX_ITERATOR = proc { |b| }
-	EMPTY_NEIGHBOR_ITERATOR = proc { |x, b| }
-	
-	# Create a new ImplicitGraph, which is by default empty. The caller should
-	# configure the with vertex and neighbor iterators. If the graph is directed
-	# the client should set directed to true. The default value for _directed_
-	# is false. 
-	def initialize
-	  @directed = false
-	  @vertex_iterator = EMPTY_VERTEX_ITERATOR
-	  @adjacent_iterator = EMPTY_NEIGHBOR_ITERATOR
-	  yield self if block_given?				# let client overwrite defaults
-	end
-
-	# Returns the value of @directed.
-	def directed?; @directed; end
-	
-	def each_vertex (&block)	# :nodoc:
-	  @vertex_iterator.call(block)
-	end
-
-	def each_adjacent (v, &block) # :nodoc:
-	  @adjacent_iterator.call(v,block)
-	end
-
-	def each_edge (&block) # :nodoc:
-	  if defined? @edge_iterator
-		@edge_iterator.call(block)
-	  else
-		super					# use default implementation
-	  end
-	end
-
-	# Sets the vertex_iterator to _block_ which must be a block of one parameter
-	# which again is the block called by each_vertex.
-	def vertex_iterator (&block)
-	  @vertex_iterator = block
-	end
-
-	# Sets the adjacent_iterator to _block_ which must be a block of two
-	# parameters: 
-	# The first parameter is the vertex the neighbors of which are to be
-	# traversed. The second is the block which will be called for each neighbor
-	# of this vertex.
-	def adjacent_iterator (&block)
-	  @adjacent_iterator = block
-	end
-
-	# Sets the edge_iterator to _block_ which must be a block of two parameters:
-	# The first parameter is the source of the edges an the second is the target
-	# of the edge.
-	def edge_iterator (&block)
-	  @edge_iterator = block
-	end
-  end
+
+    include Graph
+
+    attr_writer :directed
+
+    EMPTY_VERTEX_ITERATOR   = proc { |b|    }
+    EMPTY_NEIGHBOR_ITERATOR = proc { |x, b| }
+        
+    # Create a new ImplicitGraph, which is empty by default.  The caller should
+    # configure the graph using vertex and neighbor iterators.  If the graph is
+    # directed, the client should set _directed_ to true.  The default value
+    # for _directed_ is false. 
+
+    def initialize
+      @directed = false
+      @vertex_iterator   = EMPTY_VERTEX_ITERATOR
+      @adjacent_iterator = EMPTY_NEIGHBOR_ITERATOR
+      yield self if block_given?  # Let client overwrite defaults.
+    end
+
+    # Returns the value of @directed.
+
+    def directed?
+      @directed
+    end
+        
+    def each_vertex (&block)			# :nodoc:
+      @vertex_iterator.call(block)
+    end
+
+    def each_adjacent (v, &block)		# :nodoc:
+      @adjacent_iterator.call(v, block)
+    end
+
+    def each_edge (&block)			# :nodoc:
+      if defined? @edge_iterator
+        @edge_iterator.call(block)
+      else
+        super					# use default implementation
+      end
+    end
+
+    # Sets the vertex_iterator to _block_,
+    # which must be a block of one parameter
+    # which again is the block called by each_vertex.
+
+    def vertex_iterator (&block)
+      @vertex_iterator = block
+    end
+
+    # Sets the adjacent_iterator to _block_,
+    # which must be a block of two parameters: 
+    #
+    #   The first parameter is the vertex the neighbors of which are to be
+    #   traversed.
+    #
+    #   The second is the block which will be called for each neighbor
+    #   of this vertex.
+
+    def adjacent_iterator (&block)
+      @adjacent_iterator = block
+    end
+
+    # Sets the edge_iterator to _block_, which must be a block of two
+    # parameters: The first parameter is the source of the edges; the
+    # second is the target of the edge.
+
+    def edge_iterator (&block)
+      @edge_iterator = block
+    end
+
+  end		# class ImplicitGraph
+
 
   module Graph
-	# ---
-	# === Graph adaptors
-	#
-	# Return a new ImplicitGraph which has as vertices all vertices of the
-	# receiver which satisfy the predicate _filter_.
-	#
-	# The methods provides similar functionaty as the BGL graph adapter
-	# filtered_graph (see BOOST_DOC/filtered_graph.html). 
-	#
-	# ==== Example
-	#
-	# 	def complete (n)
-	# 	  set = n.integer? ? (1..n) : n
-	# 	  RGL::ImplicitGraph.new { |g|
-	# 		g.vertex_iterator { |b| set.each(&b) }
-	# 		g.adjacent_iterator { |x, b|
-	# 		  set.each { |y| b.call(y) unless x == y }
-	# 		}
-	# 	  }
-	# 	end
-	#
-	# 	complete(4).to_s =>	"(1=2)(1=3)(1=4)(2=3)(2=4)(3=4)"
-	# 	complete(4).vertices_filtered_by {|v| v != 4}.to_s => "(1=2)(1=3)(2=3)"
-	def vertices_filtered_by (&filter)
-	  implicit_graph {|g|
-		g.vertex_iterator { |b|
-		  self.each_vertex { |v| b.call(v) if filter.call(v) }
-		}
-		g.adjacent_iterator { |v, b|
-		  self.each_adjacent(v) { |u| b.call(u) if filter.call(u) }
-		}
-	  }
-	end
-
-	# Return a new ImplicitGraph which has as edges all edges of the receiver
-	# which satisfy the predicate _filter_ (a block with to parameters).
-	#
-	# ==== Example
-	#
-	# 	g = complete(7).edges_filtered_by {|u,v| u+v == 7}
-	#	g.to_s => "(1=6)(2=5)(3=4)"
-	#	g.vertices => [1, 2, 3, 4, 5, 6, 7]
-	def edges_filtered_by (&filter)
-	  implicit_graph {
-		|g|
-		g.adjacent_iterator { |v, b|
-		  self.each_adjacent(v) { |u|
-			b.call(u) if filter.call(v,u)
-		  }
-		}
-		g.edge_iterator { |b|
-		  self.each_edge {|u,v| b.call(u,v) if filter.call(u,v)}
-		}
-	  }
-	end
-
-	# Return a new ImplicitGraph which is isomorphic (i.e. has same edges and
-	# vertices) to the receiver. It is a shortcut also used by
-	# edges_filtered_by and vertices_filtered_by.
-	def implicit_graph
-	  result = ImplicitGraph.new {|g|
-		g.vertex_iterator { |b| self.each_vertex(&b)}
-		g.adjacent_iterator { |v, b| self.each_adjacent(v,&b)}
-		g.directed = self.directed?
-	  }
-	  yield result if block_given? # let client overwrite defaults
-	  result
-	end
-  end							# module Graph
-end
+
+    # ---
+    # === Graph adaptors
+    #
+    # Return a new ImplicitGraph which has as vertices all vertices of the
+    # receiver which satisfy the predicate _filter_.
+    #
+    # The methods provides similar functionaty as the BGL graph adapter
+    # filtered_graph (see BOOST_DOC/filtered_graph.html). 
+    #
+    # ==== Example
+    #
+    #   def complete (n)
+    #     set = n.integer? ? (1..n) : n
+    #     RGL::ImplicitGraph.new { |g|
+    #           g.vertex_iterator { |b| set.each(&b) }
+    #           g.adjacent_iterator { |x, b|
+    #             set.each { |y| b.call(y) unless x == y }
+    #           }
+    #     }
+    #   end
+    #
+    #   complete(4).to_s =>     "(1=2)(1=3)(1=4)(2=3)(2=4)(3=4)"
+    #   complete(4).vertices_filtered_by {|v| v != 4}.to_s => "(1=2)(1=3)(2=3)"
+
+    def vertices_filtered_by (&filter)
+      implicit_graph { |g|
+        g.vertex_iterator { |b|
+          self.each_vertex { |v| b.call(v) if filter.call(v) }
+        }
+        g.adjacent_iterator { |v, b|
+          self.each_adjacent(v) { |u| b.call(u) if filter.call(u) }
+        }
+      }
+    end
+
+    # Return a new ImplicitGraph which has as edges all edges of the receiver
+    # which satisfy the predicate _filter_ (a block with two parameters).
+    #
+    # ==== Example
+    #
+    #       g = complete(7).edges_filtered_by {|u,v| u+v == 7}
+    #       g.to_s     => "(1=6)(2=5)(3=4)"
+    #       g.vertices => [1, 2, 3, 4, 5, 6, 7]
+
+    def edges_filtered_by (&filter)
+      implicit_graph { |g|
+        g.adjacent_iterator { |v, b|
+          self.each_adjacent(v) { |u|
+            b.call(u) if filter.call(v, u)
+          }
+        }
+        g.edge_iterator { |b|
+          self.each_edge { |u,v| b.call(u, v) if filter.call(u, v) }
+        }
+      }
+    end
+
+    # Return a new ImplicitGraph which is isomorphic (i.e. has same edges and
+    # vertices) to the receiver.  It is a shortcut, also used by
+    # edges_filtered_by and vertices_filtered_by.
+
+    def implicit_graph
+      result = ImplicitGraph.new { |g|
+        g.vertex_iterator { |b| self.each_vertex(&b) }
+        g.adjacent_iterator { |v, b| self.each_adjacent(v, &b) }
+        g.directed = self.directed?
+      }
+      yield result if block_given? # let client overwrite defaults
+      result
+    end
+
+  end		# module Graph
+end		# module RGL

data/lib/rgl/mutable.rb

@@ -1,54 +1,75 @@
+# mutable.rb
+
 require 'rgl/base'
 
 module RGL
+
   # A MutableGraph can be changed via the addition or removal of edges and
   # vertices. 
+
   module MutableGraph
-	include Graph
-
-	# Add a new vertex _v_ to the graph. If the vertex is already in (using
-	# eql?) the method does nothing.
-	def add_vertex(v); raise NotImplementedError; end
-
-	# Inserts the edge (u,v) into the graph.
-	#
-	# Note that for undirected graphs, (u,v) is the same edge as (v,u), so after
-	# a call to the function add_edge(), this implies that edge (u,v) will
-	# appear in the out-edges of u and (u,v) (or equivalently (v,u)) will appear
-	# in the out-edges of 
-	# v. Put another way, v will be adjacent to u and u will be adjacent to v. 
-	def add_edge(u, v); raise NotImplementedError; end
-
-	# Add all objects in _a_ to the vertex set.
-	def add_vertices (*a)
-	  a.each {|v| add_vertex v}
-	end
-
-	# Add all edges in the _edges_ array to the edge set. Element of the array
-	# can be both two element arrays or instances of DirectedEdge or
-	# UnDirectedEdge. 
-	def add_edges (*edges)
-	  edges.each {|edge| add_edge(edge[0],edge[1])}
-	end
-
-	# Remove u from the vertex set of the graph. All edges who's target is _v_
-	# are also removed from the edge set of the graph.
-	#
-	# Postcondition: num_vertices is one less, _v_ no longer appears in the
-	# vertex set of the graph and there no edge with source or target _v_.
-	def remove_vertex(v); raise NotImplementedError; end
-
-	# Remove the edge (u,v) from the graph. If the graph allows parallel edges
-	# this remove all occurrences of (u,v).
-	# 
-	# Precondition: u and v are vertices in the graph.
-	# Postcondition: (u,v) is no longer in the edge set for g.
-	def remove_edge(u, v); raise NotImplementedError; end
-
-	# Remove all vertices specified by the array a from the graph calling
-	# remove_vertex.
-	def remove_vertices (*a)
-	  a.each {|v| remove_vertex v}
-	end
-  end
-end
+
+    include Graph
+
+    # Add a new vertex _v_ to the graph.  If the vertex is already in the
+    # graph (tested via eql?), the method does nothing.
+
+    def add_vertex (v)
+      raise NotImplementedError
+    end
+
+    # Inserts the edge (u,v) into the graph.
+    #
+    # Note that for undirected graphs, (u,v) is the same edge as (v,u), so
+    # after a call to the function add_edge(), this implies that edge (u,v)
+    # will appear in the out-edges of u and (u,v) (or equivalently (v,u))
+    # will appear in the out-edges of v.  Put another way, v will be adjacent
+    # to u and u will be adjacent to v. 
+
+    def add_edge (u, v)
+      raise NotImplementedError
+    end
+
+    # Add all objects in _a_ to the vertex set.
+
+    def add_vertices (*a)
+      a.each { |v| add_vertex v }
+    end
+
+    # Add all edges in the _edges_ array to the edge set.  Elements of the
+    # array can be both two-element arrays or instances of DirectedEdge or
+    # UnDirectedEdge. 
+
+    def add_edges (*edges)
+      edges.each { |edge| add_edge(edge[0], edge[1]) }
+    end
+
+    # Remove u from the vertex set of the graph.  All edges whose target is
+    # _v_ are also removed from the edge set of the graph.
+    #
+    # Postcondition: num_vertices is one less, _v_ no longer appears in the
+    # vertex set of the graph, and there no edge with source or target _v_.
+
+    def remove_vertex (v)
+      raise NotImplementedError
+    end
+
+    # Remove the edge (u,v) from the graph.  If the graph allows parallel
+    # edges, this removes all occurrences of (u,v).
+    # 
+    # Precondition: u and v are vertices in the graph.
+    # Postcondition: (u,v) is no longer in the edge set for g.
+
+    def remove_edge (u, v)
+      raise NotImplementedError
+    end
+
+    # Remove all vertices specified by the array a from the graph by calling
+    # remove_vertex.
+
+    def remove_vertices (*a)
+      a.each { |v| remove_vertex v }
+    end
+
+  end		# module MutableGraph
+end		# module RGL

data/lib/rgl/rdot.rb

@@ -1,168 +1,216 @@
+# rdot.rb
 # 
-# $Id: rdot.rb,v 1.2 2002/11/13 21:53:26 monora Exp $
+# $Id: rdot.rb,v 1.4 2005/03/26 15:06:36 wsdng Exp $
 #
-# This is a modified version of dot.rb from Dave Thomas rdoc project. I renamed
-# it to rdot.rb to avoid collision with an installed rdoc/dot.
+# This is a modified version of dot.rb from Dave Thomas's rdoc project.  I
+# renamed it to rdot.rb to avoid collision with an installed rdoc/dot.
 #
 # It also supports undirected edges.
 
 module DOT
     
-    # these glogal vars are used to make nice graph source
-    $tab = '    '
-    $tab2 = $tab * 2
+  # These glogal vars are used to make nice graph source.
+
+  $tab  = '    '
+  $tab2 = $tab * 2
     
-    # if we don't like 4 spaces, we can change it any time
-    def change_tab( t )
-        $tab = t
-        $tab2 = t * 2
-    end
+  # if we don't like 4 spaces, we can change it any time
+
+  def change_tab (t)
+    $tab  = t
+    $tab2 = t * 2
+  end
     
-    # options for node declaration
-    NODE_OPTS = [
-        'bgcolor',
-        'color',
-        'fontcolor',
-        'fontname',
-        'fontsize',
-        'heigth',
-        'width',
-        'label',
-        'layer',
-            'rank',
-        'shape',
-        'shapefile',
-        'style',
-    ]
+  # options for node declaration
+
+  NODE_OPTS = [
+    # attributes due to
+    # http://www.graphviz.org/Documentation/dotguide.pdf
+    # March, 26, 2005
+    'bottomlabel', # auxiliary label for nodes of shape M*
+    'color', # default: black; node shape color
+    'comment', # any string (format-dependent)
+    'distortion', # default: 0.0; node distortion for shape=polygon
+    'fillcolor', # default: lightgrey/black; node fill color
+    'fixedsize', # default: false; label text has no affect on node size
+    'fontcolor', # default: black; type face color
+    'fontname', # default: Times-Roman; font family
+    'fontsize', #default: 14; point size of label
+    'group', # name of node�s group
+    'height', # default: .5; height in inches
+    'label', # default: node name; any string
+    'layer', # default: overlay range; all, id or id:id
+    'orientation', # dafault: 0.0; node rotation angle
+    'peripheries', # shape-dependent number of node boundaries
+    'regular', # default:  false; force polygon to be regular
+    'shape', # default: ellipse; node shape; see Section 2.1 and Appendix E
+    'shapefile', # external EPSF or SVG custom shape file
+    'sides', # default: 4; number of sides for shape=polygon
+    'skew' , # default: 0.0; skewing of node for shape=polygon
+    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'toplabel', # auxiliary label for nodes of shape M*
+    'URL', # URL associated with node (format-dependent)
+    'width', # default: .75; width in inches
+    'z', #default: 0.0; z coordinate for VRML output
+
+    # maintained for backward compatibility or rdot internal
+    'bgcolor',
+    'rank'
+  ]
     
-    # options for edge declaration
-    EDGE_OPTS = [
-        'color',
-        'decorate',
-        'dir',
-        'fontcolor',
-        'fontname',
-        'fontsize',
-        'id',
-        'label',
-        'layer',
-        'minlen',
-        'style',
-        'weight'
-    ]
+  # options for edge declaration
+
+  EDGE_OPTS = [
+    'arrowhead', # default: normal; style of arrowhead at head end
+    'arrowsize', # default: 1.0; scaling factor for arrowheads
+    'arrowtail', # default: normal; style of arrowhead at tail end
+    'color', # default: black; edge stroke color
+    'comment', # any string (format-dependent)
+    'constraint', # default: true use edge to affect node ranking
+    'decorate', # if set, draws a line connecting labels with their edges
+    'dir', # default: forward; forward, back, both, or none
+    'fontcolor', # default: black type face color
+    'fontname', # default: Times-Roman; font family
+    'fontsize', # default: 14; point size of label
+    'headlabel', # label placed near head of edge
+    'headport', # n,ne,e,se,s,sw,w,nw
+    'headURL', # URL attached to head label if output format is ismap
+    'label', # edge label
+    'labelangle', # default: -25.0; angle in degrees which head or tail label is rotated off edge
+    'labeldistance', # default: 1.0; scaling factor for distance of head or tail label from node
+    'labelfloat', # default: false; lessen constraints on edge label placement
+    'labelfontcolor', # default: black; type face color for head and tail labels
+    'labelfontname', # default: Times-Roman; font family for head and tail labels
+    'labelfontsize', # default: 14 point size for head and tail labels
+    'layer', # default: overlay range; all, id or id:id
+    'lhead', # name of cluster to use as head of edge
+    'ltail', # name of cluster to use as tail of edge
+    'minlen', # default: 1 minimum rank distance between head and tail
+    'samehead', # tag for head node; edge heads with the same tag are merged onto the same port
+    'sametail', # tag for tail node; edge tails with the same tag are merged onto the same port
+    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+    'taillabel', # label placed near tail of edge
+    'tailport', # n,ne,e,se,s,sw,w,nw
+    'tailURL', # URL attached to tail label if output format is ismap
+    'weight', # default: 1; integer cost of stretching an edge
+
+    # maintained for backward compatibility or rdot internal
+    'id'
+  ]
     
-    # options for graph declaration
-    GRAPH_OPTS = [
-        'bgcolor',
-        'center',
-        'clusterrank',
-        'color',
-        'concentrate',
-        'fontcolor',
-        'fontname',
-        'fontsize',
-        'label',
-        'layerseq',
-        'margin',
-        'mclimit',
-        'nodesep',
-        'nslimit',
-        'ordering',
-        'orientation',
-        'page',
-        'rank',
-        'rankdir',
-        'ranksep',
-        'ratio',
-        'size'
-    ]
+  # options for graph declaration
+
+  GRAPH_OPTS = [
+    'bgcolor',
+    'center', 'clusterrank', 'color', 'concentrate',
+    'fontcolor', 'fontname', 'fontsize',
+    'label', 'layerseq',
+    'margin', 'mclimit',
+    'nodesep', 'nslimit',
+    'ordering', 'orientation',
+    'page',
+    'rank', 'rankdir', 'ranksep', 'ratio',
+    'size'
+  ]
     
-    # a root class for any element in dot notation
-    class DOTSimpleElement
-        attr_accessor :name
+  # a root class for any element in dot notation
 
-        def initialize( params = {} )
-            @label = params['name'] ? params['name'] : ''
-        end
+  class DOTSimpleElement
 
-        def to_s
-            @name
-        end
+    attr_accessor :name
+
+    def initialize (params = {})
+      @label = params['name'] ? params['name'] : ''
+    end
+
+    def to_s
+      @name
     end
+  end
     
-    # an element that have options ( node, edge or graph )
-    class DOTElement < DOTSimpleElement
-        #attr_reader :parent
-        attr_accessor :name, :options
-
-        def initialize( params = {}, option_list = [] )
-            super( params )
-            @name = params['name'] ? params['name'] : nil 
-            @parent = params['parent'] ? params['parent'] : nil
-            @options = {}
-            option_list.each{ |i|
-                @options[i] = params[i] if params[i]
-            }
-            @options['label'] ||= @name if @name != 'node'
-        end
+  # an element that has options ( node, edge, or graph )
+
+  class DOTElement < DOTSimpleElement
+
+    # attr_reader :parent
+    attr_accessor :name, :options
+
+    def initialize (params = {}, option_list = [])
+      super(params)
+      @name   = params['name']   ? params['name']   : nil 
+      @parent = params['parent'] ? params['parent'] : nil
+      @options = {}
+      option_list.each{ |i|
+        @options[i] = params[i] if params[i]
+      }
+      @options['label'] ||= @name if @name != 'node'
+    end
         
-        def each_option
-            @options.each{ |i| yield i }
-        end
-
-        def each_option_pair
-            @options.each_pair{ |key, val| yield key, val }
-        end
-
-        #def parent=( thing )
-        #    @parent.delete( self ) if defined?( @parent ) and @parent
-        #    @parent = thing
-        #end
+    def each_option
+      @options.each{ |i| yield i }
     end
+
+    def each_option_pair
+      @options.each_pair{ |key, val| yield key, val }
+    end
+
+    #def parent=( thing )
+    #    @parent.delete( self ) if defined?( @parent ) and @parent
+    #    @parent = thing
+    #end
+
+  end
     
     
-    # this is used when we build nodes that have shape=record
-    # ports don't have options :)
-    class DOTPort < DOTSimpleElement
-        attr_accessor :label
+  # This is used when we build nodes that have shape=record
+  # ports don't have options :)
+
+  class DOTPort < DOTSimpleElement
+
+    attr_accessor :label
         
-        def initialize( params = {} )
-            super( params )
-            @name = params['label'] ? params['label'] : ''
-        end
-        def to_s
-            ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
-        end
+    def initialize (params = {})
+      super(params)
+      @name = params['label'] ? params['label'] : ''
+    end
+
+    def to_s
+      ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
     end
+  end
     
-    # node element
-    class DOTNode < DOTElement
-        @ports
+  # node element
+
+  class DOTNode < DOTElement
 
-        def initialize( params = {}, option_list = NODE_OPTS )
-            super( params, option_list )
-            @ports = params['ports'] ? params['ports'] : []
-        end
+    @ports
+
+    def initialize (params = {}, option_list = NODE_OPTS)
+      super(params, option_list)
+      @ports = params['ports'] ? params['ports'] : []
+    end
 
-        def each_port
-            @ports.each{ |i| yield i }
-        end
+    def each_port
+      @ports.each { |i| yield i }
+    end
+
+    def << (thing)
+      @ports << thing
+    end
 
-        def << ( thing )
-            @ports << thing
-        end
+    def push (thing)
+      @ports.push(thing)
+    end
 
-        def push ( thing )
-            @ports.push( thing )
-        end
+    def pop
+      @ports.pop
+    end
 
-        def pop
-            @ports.pop
-        end
+    def to_s (t = '')
 
-        def to_s( t = '' )
+      # This code is totally incomprehensible; it needs to be replaced!
 
-            label = @options['shape'] != 'record' && @ports.length == 0 ?
+      label = @options['shape'] != 'record' && @ports.length == 0 ?
                 @options['label'] ? 
                     t + $tab + "label = \"#{@options['label']}\"\n" :
                     '' :
@@ -180,85 +228,100 @@ module DOT
             }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) + 
             label +
             t + "]\n" 
-        end
+      end
+
+  end		# class DOTNode
+
+  # A subgraph element is the same to graph, but has another header in dot
+  # notation.
+
+  class DOTSubgraph < DOTElement
+
+    @nodes
+    @dot_string
+
+    def initialize (params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @nodes      = params['nodes'] ? params['nodes'] : []
+      @dot_string = 'graph'
     end
 
-    # subgraph element is the same to graph, but has another header in dot
-    # notation
-    class DOTSubgraph < DOTElement
-        @nodes
-        @dot_string
-
-        def initialize( params = {}, option_list = GRAPH_OPTS )
-            super( params, option_list )
-            @nodes = params['nodes'] ? params['nodes'] : []
-            @dot_string = 'graph'
-        end
-
-        def each_node
-            @nodes.each{ |i| yield i }
-        end
-
-        def << ( thing )
-            @nodes << thing
-        end
+    def each_node
+      @nodes.each{ |i| yield i }
+    end
+
+    def << (thing)
+      @nodes << thing
+    end
        
-        def push( thing )
-            @nodes.push( thing )
-        end
-
-        def pop
-            @nodes.pop
-        end
-
-        def to_s( t = '' )
-          hdr = t + "#{@dot_string} #{@name} {\n"
-
-          options = @options.to_a.collect{ |name, val|
-            val && name != 'label' ? 
-            t + $tab + "#{name} = #{val}" : 
-              name ? t + $tab + "#{name} = \"#{val}\"" : nil
-          }.compact.join( "\n" ) + "\n"
-
-          nodes = @nodes.collect{ |i|
-            i.to_s( t + $tab )
-          }.join( "\n" ) + "\n" 
-          hdr + options + nodes + t + "}\n"
-        end
+    def push (thing)
+      @nodes.push( thing )
     end
 
-    # this is graph
-    class DOTDigraph < DOTSubgraph
-        def initialize( params = {}, option_list = GRAPH_OPTS )
-            super( params, option_list )
-            @dot_string = 'digraph'
-        end
+    def pop
+      @nodes.pop
     end
 
-    # this is edge
-    class DOTEdge < DOTElement
-        attr_accessor :from, :to
-        def initialize( params = {}, option_list = EDGE_OPTS )
-            super( params, option_list )
-            @from = params['from'] ? params['from'] : nil
-            @to = params['to'] ? params['to'] : nil
-        end
+    def to_s (t = '')
+      hdr = t + "#{@dot_string} #{@name} {\n"
+
+      options = @options.to_a.collect{ |name, val|
+        val && name != 'label' ? 
+          t + $tab + "#{name} = #{val}" : 
+          name ? t + $tab + "#{name} = \"#{val}\"" : nil
+      }.compact.join( "\n" ) + "\n"
+
+      nodes = @nodes.collect{ |i|
+        i.to_s( t + $tab )
+      }.join( "\n" ) + "\n" 
+      hdr + options + nodes + t + "}\n"
+    end
+
+  end		# class DOTSubgraph
+
+  # This is a graph.
+
+  class DOTDigraph < DOTSubgraph
+
+    def initialize (params = {}, option_list = GRAPH_OPTS)
+      super(params, option_list)
+      @dot_string = 'digraph'
+    end
+
+  end		# class DOTDigraph
+
+  # This is an edge.
+
+  class DOTEdge < DOTElement
+
+    attr_accessor :from, :to
+
+    def initialize (params = {}, option_list = EDGE_OPTS)
+      super(params, option_list)
+      @from = params['from'] ? params['from'] : nil
+      @to   = params['to'] ? params['to'] : nil
+    end
        
-		def edge_link; '--'; end
-        def to_s( t = '' )
-		  t + "#{@from} #{edge_link} #{to} [\n" +
-            @options.to_a.collect{ |i|
-                i[1] && i[0] != 'label' ? 
-                    t + $tab + "#{i[0]} = #{i[1]}" : 
-                    i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
-            }.compact.join( "\n" ) + "\n" + t + "]\n"
-        end
+    def edge_link
+      '--'
     end
-	  
-	class DOTDirectedEdge < DOTEdge
-	  def edge_link; '->'; end
-	end
-end
 
+    def to_s (t = '')
+      t + "#{@from} #{edge_link} #{to} [\n" +
+          @options.to_a.collect{ |i|
+            i[1] && i[0] != 'label' ? 
+              t + $tab + "#{i[0]} = #{i[1]}" : 
+              i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
+          }.compact.join( "\n" ) + "\n" + t + "]\n"
+    end
+
+  end		# class DOTEdge
+          
+  class DOTDirectedEdge < DOTEdge
 
+    def edge_link
+      '->'
+    end
 
+  end                           # class DOTDirectedEdge
+end                             # module DOT