utilrb 1.6.6 → 2.0

data/lib/utilrb/module/inherited_enumerable.rb

@@ -1,200 +1,6 @@
-require 'utilrb/object/attribute'
-require 'utilrb/object/singleton_class'
-require 'utilrb/enumerable/uniq'
-require 'utilrb/module/include'
+require 'utilrb/models/inherited_enumerable'
 
 class Module
-    def define_inherited_enumerable(name, attribute_name = name, options = Hash.new, &init) # :nodoc:
-        # Set up the attribute accessor
-	attribute(attribute_name, &init)
-	class_eval { private "#{attribute_name}=" }
-
-	options[:enum_with] ||= :each
-
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def all_#{name}; each_#{name}.to_a end
-        def self_#{name}; @#{attribute_name} end
-        EOF
-
-        if options[:map]
-            class_eval <<-EOF, __FILE__, __LINE__+1
-            def each_#{name}(key = nil, uniq = true)
-	        if !block_given?
-	            return enum_for(:each_#{name}, key, uniq)
-		end
-
-		if key
-		    for klass in ancestors
-			if klass.instance_variable_defined?(:@#{attribute_name})
-			    if klass.#{attribute_name}.has_key?(key)
-				yield(klass.#{attribute_name}[key])
-				return self if uniq
-			    end
-			end
-		    end
-		elsif !uniq
-		    for klass in ancestors
-			if klass.instance_variable_defined?(:@#{attribute_name})
-			    klass.#{attribute_name}.#{options[:enum_with]} { |el| yield(el) }
-			end
-		    end
-		else
-		    seen = Set.new
-		    for klass in ancestors
-			if klass.instance_variable_defined?(:@#{attribute_name})
-			    klass.#{attribute_name}.#{options[:enum_with]} do |el| 
-				unless seen.include?(el.first)
-				    seen << el.first
-				    yield(el)
-				end
-			    end
-			end
-		    end
-
-		end
-                self
-            end
-            def find_#{name}(key)
-                each_#{name}(key, true) do |value|
-                    return value
-                end
-                nil
-            end
-            def has_#{name}?(key)
-		for klass in ancestors
-		    if klass.instance_variable_defined?(:@#{attribute_name})
-			return true if klass.#{attribute_name}.has_key?(key)
-		    end
-		end
-		false
-            end
-            EOF
-        else
-            class_eval <<-EOF, __FILE__, __LINE__+1
-            def each_#{name}
-	        if !block_given?
-	            return enum_for(:each_#{name})
-		end
-
-		for klass in ancestors
-		    if klass.instance_variable_defined?(:@#{attribute_name})
-			klass.#{attribute_name}.#{options[:enum_with]} { |el| yield(el) }
-		    end
-		end
-		self
-            end
-            EOF
-        end
-    end
-
-    # Defines an attribute as being enumerable in the class instance and in the
-    # whole class inheritance hierarchy.  More specifically, it defines a
-    # <tt>each_#{name}(&iterator)</tt> instance method and a <tt>each_#{name}(&iterator)</tt>
-    # class method which iterates (in order) on 
-    # - the instance #{name} attribute
-    # - the singleton class #{name} attribute
-    # - the class #{name} attribute
-    # - the superclass #{name} attribute
-    # - the superclass' superclass #{name} attribute
-    # ...
-    #
-    # This method can be used on modules, in which case the module is used as if 
-    # it was part of the inheritance hierarchy.
-    #
-    # The +name+ option defines the enumeration method name (+value+ will
-    # define a +each_value+ method). +attribute_name+ defines the attribute
-    # name. +init+ is a block called to initialize the attribute. 
-    # Valid options in +options+ are: 
-    # map:: 
-    #   If true, the attribute should respond to +[]+. In that case, the
-    #   enumeration method is each_value(key = nil, uniq = false) If +key+ is
-    #   given, we iterate on the values given by <tt>attribute[key]</tt>. If
-    #   +uniq+ is true, the enumeration will yield at most one value for each
-    #   +key+ found (so, if both +key+ and +uniq+ are given, the enumeration
-    #   yields at most one value). See the examples below
-    # enum_with:: the enumeration method of the enumerable, if it is not +each+
-    #
-    # === Example
-    # Let's define some classes and look at the ancestor chain
-    #
-    #   class A;  end
-    #   module M; end
-    #   class B < A; include M end
-    #   A.ancestors # => [A, Object, Kernel]
-    #   B.ancestors # => [B, M, A, Object, Kernel]
-    #
-    # ==== Attributes for which 'map' is not set
-    #
-    #   class A
-    #     inherited_enumerable("value", "values") do
-    #         Array.new
-    #     end
-    #   end
-    #   module M
-    #     inherited_enumerable("mod") do
-    #         Array.new
-    #     end
-    #   end
-    #   
-    #   A.values << 1 # => [1]
-    #   B.values << 2 # => [2]
-    #   M.mod << 1 # => [1]
-    #   b = B.new 
-    #   class << b
-    #       self.values << 3 # => [3]
-    #       self.mod << 4 # => [4]
-    #   end
-    #   M.mod << 2 # => [1, 2]
-    #   
-    #   A.enum_for(:each_value).to_a # => [1]
-    #   B.enum_for(:each_value).to_a # => [2, 1]
-    #   b.singleton_class.enum_for(:each_value).to_a # => [3, 2, 1]
-    #   b.singleton_class.enum_for(:each_mod).to_a # => [4, 1, 2]
-    #
-    # ==== Attributes for which 'map' is set
-    #
-    #   class A
-    #     inherited_enumerable("mapped", "map", :map => true) do
-    #         Hash.new { |h, k| h[k] = Array.new }
-    #     end
-    #   end
-    #   
-    #   A.map['name'] = 'A' # => "A"
-    #   A.map['universe'] = 42
-    #   B.map['name'] = 'B' # => "B"
-    #   B.map['half_of_it'] = 21
-    #   
-    # Let's see what happens if we don't specify the key option.  
-    #   A.enum_for(:each_mapped).to_a # => [["name", "A"], ["universe", 42]]
-    # If the +uniq+ option is set (the default), we see only B's value for 'name'
-    #   B.enum_for(:each_mapped).to_a # => [["half_of_it", 21], ["name", "B"], ["universe", 42]]
-    # If the +uniq+ option is not set, we see both values for 'name'. Note that
-    # since 'map' is a Hash, the order of keys in one class is not guaranteed.
-    # Nonetheless, we have the guarantee that values from B appear before
-    # those from A
-    #   B.enum_for(:each_mapped, nil, false).to_a # => [["half_of_it", 21], ["name", "B"], ["name", "A"], ["universe", 42]]
-    #
-    #
-    # Now, let's see how 'key' behaves
-    #   A.enum_for(:each_mapped, 'name').to_a # => ["A"]
-    #   B.enum_for(:each_mapped, 'name').to_a # => ["B"]
-    #   B.enum_for(:each_mapped, 'name', false).to_a # => ["B", "A"]
-    #
-    def inherited_enumerable(name, attribute_name = name, options = Hash.new, &init)
-	singleton_class.class_eval { define_inherited_enumerable(name, attribute_name, options, &init) }
-
-	if is_a?(Module) && !is_a?(Class)
-	    unless const_defined?(:ClassExtension)
-		const_set(:ClassExtension, Module.new)
-	    end
-	    class_extension = const_get(:ClassExtension)
-	    class_extension.class_eval do
-		define_inherited_enumerable(name, attribute_name, options, &init)
-	    end
-	end
-    end
+    include Utilrb::Models
 end
 
-
-
-

data/lib/utilrb/objectstats.rb

@@ -19,12 +19,15 @@ module ObjectStats
     # Returns a klass => count hash counting the currently allocated objects
     # 
     # It allocates 1 Hash, which is included in the count
-    def self.count_by_class
+    def self.count_by_class(threshold = nil)
         by_class = Hash.new(0)
         ObjectSpace.each_object { |obj|
             by_class[obj.class] += 1
             by_class
         }
+        if threshold
+            by_class.delete_if { |kl, count| count < threshold }
+        end
 
         by_class
     end

data/lib/utilrb/pkgconfig.rb

@@ -45,7 +45,7 @@ module Utilrb
             attr_reader :loaded_packages
 
             def clear_cache
-                cache.clear
+                loaded_packages.clear
             end
         end
         @loaded_packages = Hash.new
@@ -76,6 +76,14 @@ module Utilrb
             find_matching_version(candidates, version_spec)
         end
 
+        # Finds the provided package and optional version and returns its
+        # PkgConfig description
+        #
+        # @param [String] version_spec version specification, of the form "op
+        # number", where op is < <= >= > or == and the version number X, X.y,
+        # ...
+        # @return [PkgConfig] the pkg-config description
+        # @raise [NotFound] if the package is not found
         def self.new(name, version_spec = nil)
             get(name, version_spec)
         end
@@ -325,7 +333,7 @@ module Utilrb
         def include_dirs
             result = Shellwords.shellsplit(cflags_only_I).map { |v| v[2..-1] }
             if result.any?(&:empty?)
-                raise Invalid, "empty include directory (-I without argument) found in pkg-config package #{name}"
+                raise Invalid.new(name), "empty include directory (-I without argument) found in pkg-config package #{name}"
             end
             result
         end
@@ -335,7 +343,7 @@ module Utilrb
         def library_dirs
             result = Shellwords.shellsplit(libs_only_L).map { |v| v[2..-1] }
             if result.any?(&:empty?)
-                raise Invalid, "empty link directory (-L without argument) found in pkg-config package #{name}"
+                raise Invalid.new(name), "empty link directory (-L without argument) found in pkg-config package #{name}"
             end
             result
         end
@@ -396,9 +404,7 @@ module Utilrb
             if path = ENV['PKG_CONFIG_PATH']
                 path.split(':').each(&block)
             end
-            yield('/usr/local/lib/pkgconfig')
-            yield('/usr/lib/pkgconfig')
-            yield('/usr/share/pkgconfig')
+            default_search_path.each(&block)
         end
 
         # Returns true if there is a package with this name
@@ -443,6 +449,36 @@ module Utilrb
                 end
             end
         end
+
+
+        FOUND_PATH_RX = /Scanning directory '(.*\/)((?:lib|share)\/.*)'$/
+        NONEXISTENT_PATH_RX = /Cannot open directory '.*\/((?:lib|share)\/.*)' in package search path:.*/
+
+        # Returns the system-wide search path that is embedded in pkg-config
+        def self.default_search_path
+            if !@default_search_path
+                output = `LANG=C PKG_CONFIG_PATH= pkg-config --debug 2>&1`.split("\n")
+                @default_search_path = output.grep(FOUND_PATH_RX).
+                    map { |l| l.gsub(FOUND_PATH_RX, '\1\2') }
+            end
+            return @default_search_path
+        end
+
+        # Returns the system-wide standard suffixes that should be appended to
+        # new prefixes to find pkg-config files
+        def self.default_search_suffixes
+            if !@default_search_suffixes
+                output = `LANG=C PKG_CONFIG_PATH= pkg-config --debug 2>&1`.split("\n")
+                found_paths = output.grep(FOUND_PATH_RX).
+                    map { |l| l.gsub(FOUND_PATH_RX, '\2') }.
+                    to_set
+                not_found = output.grep(NONEXISTENT_PATH_RX).
+                    map { |l| l.gsub(NONEXISTENT_PATH_RX, '\1') }.
+                    to_set
+                @default_search_suffixes = found_paths | not_found
+            end
+            return @default_search_suffixes
+        end
     end
 end
 

data/lib/utilrb/rake_common.rb

@@ -7,9 +7,15 @@ module Utilrb
         rescue LoadError => e
             STDERR.puts "INFO: cannot load the Hoe gem. Distribution is disabled"
             STDERR.puts "INFO: error message is: #{e.message}"
+            if ::Rake.application.options.trace
+                puts e.backtrace.join("\n  ")
+            end
         rescue Exception => e
             STDERR.puts "INFO: cannot load the Hoe gem, or Hoe fails. Distribution is disabled"
             STDERR.puts "INFO: error message is: #{e.message}"
+            if ::Rake.application.options.trace
+                puts e.backtrace.join("\n  ")
+            end
         end
 
         def self.rdoc
@@ -19,9 +25,15 @@ module Utilrb
         rescue LoadError => e
             STDERR.puts "INFO: cannot load RDoc, Documentation generation is disabled"
             STDERR.puts "INFO: error message is: #{e.message}"
+            if ::Rake.application.options.trace
+                puts e.backtrace.join("\n  ")
+            end
         rescue Exception => e
             STDERR.puts "INFO: cannot load the RDoc gem, or RDoc failed to load. Documentation generation is disabled"
             STDERR.puts "INFO: error message is: #{e.message}"
+            if ::Rake.application.options.trace
+                puts e.backtrace.join("\n  ")
+            end
         end
     end
 end

data/lib/utilrb/ruby_object_graph.rb

@@ -1,3 +1,6 @@
+require 'stringio'
+require 'utilrb/value_set'
+require 'utilrb/kernel/options'
 module Utilrb
     begin
         require 'roby/graph'
@@ -8,22 +11,46 @@ module Utilrb
 
     if has_roby_graph
     class RubyObjectGraph
+        module GraphGenerationObjectMaker
+            def __ruby_object_graph_internal__; end
+        end
         attr_reader :graph
         attr_reader :references
 
+        # Takes a snapshot of all objects currently live
         def self.snapshot
             # Doing any Ruby code that do not modify the heap is impossible. List
             # all existing objects once, and only then do the processing.
             # +live_objects+ will be referenced in itself, but we are going to
             # remove it later
             GC.disable
-            live_objects = []
+            live_objects = Array.new
             ObjectSpace.each_object do |obj|
-                if obj != live_objects
+                if obj.object_id != live_objects.object_id
                     live_objects << obj
                 end
             end
             GC.enable
+            live_objects
+        end
+
+        # Generates a graph of all the objects currently live, in dot format
+        def self.dot_snapshot(options = Hash.new)
+            r, w = IO.pipe
+            live_objects = RubyObjectGraph.snapshot
+            fork do
+                options, register_options = Kernel.filter_options options,
+                    :collapse => nil
+                ruby_graph = RubyObjectGraph.new
+                ruby_graph.register_references_to(live_objects, register_options)
+                if options[:collapse]
+                    ruby_graph.collapse(*options[:collapse])
+                end
+                w.write ruby_graph.to_dot
+                exit! true
+            end
+            w.close
+            r.read
         end
 
         def initialize
@@ -31,8 +58,22 @@ module Utilrb
             @references = Hash.new
         end
 
+        def clear
+            graph.each_edge do |from, to, info|
+                info.clear
+            end
+            graph.clear
+            references.clear
+        end
+
+        # This class is used to store any ruby object into a BGL::Graph (i.e.
+        # the live graph)
         class ObjectRef
+            # The referenced object
             attr_reader :obj
+
+            def __ruby_object_graph_internal__; end
+
             def initialize(obj)
                 @obj = obj
             end
@@ -46,34 +87,63 @@ module Utilrb
             end
         end
 
+        # Register a ruby object reference
+        #
+        # @param [ObjectRef] obj_ref the object that is referencing
+        # @param [ObjectRef] var_ref the object that is referenced
+        # @param desc the description for the link. For instance, if obj_ref
+        #   references var_ref because of an instance variable, this is going to
+        #   be the name of the instance variable
+        # @return [void]
         def add_reference(obj_ref, var_ref, desc)
             if graph.linked?(obj_ref, var_ref)
-                obj_ref[var_ref, graph] << desc
+                desc_set = obj_ref[var_ref, graph]
+                if !desc_set.include?(desc)
+                    desc_set << desc
+                end
             else
-                graph.link(obj_ref, var_ref, [desc].to_set)
+                desc_set = [desc]
+                graph.link(obj_ref, var_ref, desc_set)
             end
         end
 
-        def register_references_to(klass, orig_options = Hash.new)
-            options = Kernel.validate_options orig_options,
-                :roots => nil
-            roots = options[:roots]
-
-            live_objects = RubyObjectGraph.snapshot
+        # Creates a BGL::Graph of ObjectRef objects which stores the current
+        # ruby object graph
+        #
+        # @param [Class] klass seed 
+        # @option options [Array<Object>] roots (nil) if given, the list of root
+        #   objects. Objects that are not referenced by one of these roots will
+        #   not be included in the final graph
+        def register_references_to(live_objects, options = Hash.new)
+            orig_options = options # to exclude it from the graph
+            options = Kernel.validate_options options,
+                :roots => [Object], :excluded_classes => [], :excluded_objects => [],
+                :include_class_relation => false
+            roots_class, roots = options[:roots].partition { |obj| obj.kind_of?(Class) }
+            excluded_classes = options[:excluded_classes]
+            excluded_objects = options[:excluded_objects]
+            include_class_relation = options[:include_class_relation]
 
             # Create a single ObjectRef per (interesting) live object, so that we
             # can use a BGL::Graph to represent the reference graph.  This will be
             # what we are going to access later on. Use object IDs since we really
             # want to refer to objects and not use eql? comparisons
-            desired_seeds = []
-            excludes = [live_objects, self, orig_options, options, roots].to_value_set
+            desired_seeds = roots.map(&:object_id)
+            excludes = [live_objects, self, graph, references, orig_options, options, roots, roots_class].to_value_set
+            live_objects_total = live_objects.size
             live_objects.delete_if do |obj|
-                if excludes.include?(obj)
+                if obj.kind_of?(DRbObject)
+                    true
+                elsif excludes.include?(obj) || obj.respond_to?(:__ruby_object_graph_internal__)
                     true
                 else
                     references[obj.object_id] ||= ObjectRef.new(obj)
-                    if obj.kind_of?(klass)
-                        desired_seeds << obj.object_id
+                    if roots_class.any? { |k| obj.kind_of?(k) }
+                        if !excluded_classes.any? { |k| obj.kind_of?(k) }
+                            if !excluded_objects.include?(obj)
+                                desired_seeds << obj.object_id
+                            end
+                        end
                     end
                     false
                 end
@@ -84,12 +154,24 @@ module Utilrb
             end
             ignored_enumeration = Hash.new
 
+            names = Hash[
+                :array => "Array",
+                :value_set => "ValueSet[]",
+                :vertex => "Vertex[]",
+                :edge => "Edge[]",
+                :hash_key => "Hash[key]",
+                :hash_value => "Hash[value]",
+                :proc => "Proc",
+                :ancestor => "Ancestor"]
+            puts "RubyObjectGraph: #{live_objects.size} objects found, #{desired_seeds.size} seeds and #{live_objects_total} total live objects"
             loop do
                 old_graph_size = graph.size
                 live_objects.each do |obj|
                     obj_ref = references[obj.object_id]
 
-                    test_and_add_reference(obj_ref, obj.class, "class")
+                    if include_class_relation
+                        test_and_add_reference(obj_ref, obj.class, "class")
+                    end
 
                     for var_name in obj.instance_variables
                         var = obj.instance_variable_get(var_name)
@@ -97,32 +179,39 @@ module Utilrb
                     end
 
                     case obj
-                    when Array, ValueSet
+                    when Array
                         for var in obj
-                            test_and_add_reference(obj_ref, var, "ValueSet[]")
+                            test_and_add_reference(obj_ref, var, names[:array])
+                        end
+                    when ValueSet
+                        for var in obj
+                            test_and_add_reference(obj_ref, var, names[:value_set])
                         end
                     when BGL::Graph
                         obj.each_vertex do
-                            test_and_add_reference(obj_ref, var, "Vertex[]")
+                            test_and_add_reference(obj_ref, var, names[:vertex])
                         end
                         obj.each_edge do |_, _, info|
-                            test_and_add_reference(obj_ref, info, "Edge[]")
+                            test_and_add_reference(obj_ref, info, names[:edge])
                         end
                     when Hash
                         for var in obj
-                            2.times do |i|
-                                test_and_add_reference(obj_ref, var[i], "Hash[]")
-                            end
+                            test_and_add_reference(obj_ref, var[0], names[:hash_key])
+                            test_and_add_reference(obj_ref, var[1], names[:hash_value])
                         end
                     when Proc
                         if obj.respond_to?(:references)
                             for var in obj.references
                                 begin
-                                    test_and_add_reference(obj_ref, ObjectSpace._id2ref(var), "Proc")
+                                    test_and_add_reference(obj_ref, ObjectSpace._id2ref(var), names[:proc])
                                 rescue RangeError
                                 end
                             end
                         end
+                    when Class
+                        for ref in obj.ancestors
+                            test_and_add_reference(obj_ref, ref, names[:ancestor])
+                        end
                     else
                         if obj.respond_to?(:each)
                             if obj.kind_of?(Module) || obj.kind_of?(Class)
@@ -133,7 +222,7 @@ module Utilrb
                             else
                                 if !ignored_enumeration[obj.class]
                                     ignored_enumeration[obj.class] = true
-                                    puts "ignoring enumerator object #{obj.class}"
+                                    puts "ignoring enumerator object of class #{obj.class}"
                                 end
                             end
                         end
@@ -143,6 +232,7 @@ module Utilrb
                     break
                 end
             end
+            live_objects.clear # to avoid making it a central node in future calls
             return graph
         end
 
@@ -169,63 +259,122 @@ module Utilrb
             end
         end
 
-        def to_dot
-            if !roots
-                roots = graph.vertices.find_all do |v|
-                    v.root?(graph)
-                end.to_value_set
-            else
-                roots = roots.to_value_set
+        def live_chain_for(obj)
+            result = []
+
+            # Find one Roby task and look at the chain
+            ref = references[obj.object_id]
+            stack = [[ref.obj]]
+            graph.reverse.each_dfs(ref, BGL::Graph::TREE) do |source, target, info, kind|
+                source = source.obj
+                target = target.obj
+                if stack.last.first.object_id != source.object_id && stack.any? { |obj, _| obj.object_id == source.object_id }
+                    result << stack.dup if stack.size != 1
+                    while stack.last.first.object_id != source.object_id
+                        stack.pop
+                    end
+                end
+                stack.push [target, info]
             end
+            if stack.size != 1
+                result << stack
+            end
+            result
+        end
+
+
+        def display_live_chains(chains)
+            chains.each do |stack|
+                puts stack.map { |obj, link| "#{link} #{obj}" }.join("\n  >")
+            end
+        end
+
+        def to_dot
+            roots = graph.vertices.find_all do |v|
+                v.root?(graph)
+            end.to_value_set
 
             io = StringIO.new("")
 
+            colors = Hash[
+                :green => 'green',
+                :magenta => 'magenta',
+                :black => 'black'
+            ]
+            obj_label_format = "obj%i [label=\"%s\",color=%s];" 
+            obj_label_format_elements = []
+            edge_label_format_0 = "obj%i -> obj%i [label=\""
+            edge_label_format_1 = "\"];"
+            edge_label_format_elements = []
+
             all_seen = ValueSet.new
+            seen = ValueSet.new
             io.puts "digraph {"
             roots.each do |obj_ref|
-                seen = ValueSet.new
                 graph.each_dfs(obj_ref, BGL::Graph::ALL) do |from_ref, to_ref, all_info, kind|
-                    info = all_info.to_a.join(",")
+                    info = []
+                    for str in all_info
+                        info << str
+                    end
 
                     if all_seen.include?(from_ref)
                         graph.prune
                     else
                         from_id = from_ref.obj.object_id
                         to_id   = to_ref.obj.object_id
-                        io.puts "obj#{from_id} -> obj#{to_id} [label=\"#{info}\"]"
+
+                        edge_label_format_elements.clear
+                        edge_label_format_elements << from_id << to_id
+                        str = edge_label_format_0 % edge_label_format_elements
+                        first = true
+                        for edge_info in all_info
+                            if !first
+                                str << ","
+                            end
+                            str << edge_info
+                            first = false
+                        end
+                        str << edge_label_format_1
+
+                        io.puts str
                     end
                     seen << from_ref << to_ref
                 end
 
-                seen.each do |obj_ref|
+                for obj_ref in seen
                     if !all_seen.include?(obj_ref)
                         obj = obj_ref.obj
                         obj_id = obj_ref.obj.object_id
                         str =
                             if obj.respond_to?(:each)
-                                "#{obj.class}"
+                                "#{obj.class}: #{obj.object_id}"
                             else
                                 obj.to_s
                             end
 
+                        str = str.encode('UTF-8', :invalid => :replace, :undef => :replace, :replace => "")
+                        str = str.gsub(/[^\w\.:<>]/, "")
+
                         color =
-                            if obj.kind_of?(Roby::EventGenerator)
-                                "cyan"
-                            elsif obj.kind_of?(Roby::Task)
-                                "blue"
-                            elsif obj.kind_of?(BGL::Graph)
-                                "magenta"
+                            if obj.kind_of?(BGL::Graph)
+                                :magenta
                             elsif obj.kind_of?(Hash) || obj.kind_of?(Array) || obj.kind_of?(ValueSet)
-                                "green"
+                                :green
                             else
-                                "black"
+                                :black
                             end
 
-                        io.puts "obj#{obj_id} [label=\"#{str}\",color=#{color}];"
+                        obj_label_format_elements = [obj_id, str.gsub(/[\\"\n]/, " "), colors[color]]
+                        str = obj_label_format % obj_label_format_elements
+                        io.puts(str)
                     end
                 end
                 all_seen.merge(seen)
+                seen.clear
             end
+            roots.clear
+            all_seen.clear
+            seen.clear
             io.puts "}"
             io.string
         end