ograph 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,8 @@
+== 0.2.0
+
+* ObjectGraph now can graph ascendants of your objects
+* Support for color diffing trees was added
+
 == 0.1.0
 
 Tons of changes thanks to Eric Hodel!

data/Manifest.txt

@@ -2,4 +2,8 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
+examples/ascendants_graph.rb
+examples/diff_graph.rb
+examples/regular_graph.rb
 lib/ograph.rb
+test/test_all.rb

data/README.txt

@@ -12,6 +12,7 @@ give you a graph of your object and its relationships.
 For sample output and more sample code see:
 
 * http://flickr.com/photos/aaronp/tags/graphviz/
+* http://tenderlovemaking.com/2007/06/17/graphing-ruby-objects/
 * http://tenderlovemaking.com/2007/01/13/graphing-objects-in-memory-with-ruby/
 
 == PROBLEMS
@@ -22,7 +23,11 @@ None currently known.
 
   list = %w{ hello world how are you? }
   hash = { :list => list, :string => "tenderlovemaking.com" }
-  puts ObjectGraph.graph(hash)
+  ograph = ObjectGraph.new
+  ograph.graph(hash) do |h|
+    h.delete(:string)
+  end
+  puts ograph
 
 == INSTALL
 

data/Rakefile

@@ -9,6 +9,6 @@ Hoe.new('ograph', ObjectGraph::VERSION) do |p|
   p.summary         = p.paragraphs_of('README.txt', 3).join("\n\n")
   p.description     = p.paragraphs_of('README.txt', 3..5).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 1).first.split(/\n/)[1..-1].first.strip
-  p.changes         = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.changes         = p.paragraphs_of('History.txt', 0..2).join("\n\n")
 end
 

data/examples/ascendants_graph.rb

@@ -0,0 +1,10 @@
+require 'ograph'
+
+class A; end
+a = A.new
+struct = { :one => [], :two => [a] }
+
+grapher = ObjectGraph.new(:ascendants => true)
+grapher.graph(a)
+puts grapher
+

data/examples/diff_graph.rb

@@ -0,0 +1,11 @@
+require 'ograph'
+
+class A; end
+struct = { :one => [], :two => [A.new]}
+
+grapher = ObjectGraph.new
+grapher.graph(struct) do |s|
+  s[:one] << A.new
+  s[:two].pop
+end
+puts grapher

data/examples/regular_graph.rb

@@ -0,0 +1,11 @@
+require 'ograph'
+
+# Example of graphing an arbitrary data structure.
+
+class A; end
+struct = { :one => [A.new] }
+
+grapher = ObjectGraph.new
+grapher.graph(struct)
+puts grapher
+

data/lib/ograph.rb

@@ -41,11 +41,12 @@
 #   end
 
 class ObjectGraph
+  attr_accessor :nodes
 
   ##
   # The version of ObjectGraph you are currently using.
 
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 
   ##
   # Characters we need to escape
@@ -59,7 +60,7 @@ class ObjectGraph
 
   def self.graph(target, opts = {})
     graph = new opts
-    graph.add target
+    graph.graph target
     graph.to_s
   end
 
@@ -72,94 +73,199 @@ class ObjectGraph
   # :show_nil:: Draw nil (and edges to nil.)
 
   def initialize(opts = {})
-    defaults = { :class_filter => //, :show_ivars => true, :show_nil => true }
-    @opts = defaults.merge opts
+    @opts = { :class_filter => //,
+              :show_ivars   => true,
+              :show_nil     => true,
+              :ascendants   => false,
+              :descendants  => true,
+    }.merge opts
+
+    @nodes         = {}
+    @preprocess_callback = nil
+  end
 
-    @stack         = []
-    @object_links  = []
-    @seen_objects  = []
-    @seen_hash     = {}
+  ##
+  # Adds +target+ to the graph
+  def graph(target)
+    GC.start
+    add_ascendants(target)  if @opts[:ascendants]
+    add_descendants(target) if @opts[:descendants]
+    if block_given?
+      yield target
+      GC.start
+      diff(target)
+    end
+  end
 
-    @preprocess_callback = nil
+  ##
+  # Combines +target+ with the current graph and highlights differences
+
+  def diff(target)
+    old_nodes = @nodes
+    @nodes = {}
+    graph(target)
+    new_nodes   = @nodes.keys - old_nodes.keys
+    lost_nodes  = old_nodes.keys - @nodes.keys
+
+    (@nodes.keys & old_nodes.keys).each do |object_id|
+      old = old_nodes[object_id].pointers.values
+      new = @nodes[object_id].pointers.values
+
+      (old - new).flatten.each do |lost_link|
+        lost_link.options = { :color => 'red' }
+        @nodes[object_id].lost_links << lost_link
+      end
+    end
+
+    # Color the lost nodes and add them to the graph
+    lost_nodes.each do |object_id|
+      old_nodes[object_id].options['color'] = 'hotpink2'
+      @nodes[object_id] = old_nodes[object_id]
+    end
+
+    # Color the new nodes
+    new_nodes.each do |object_id|
+      @nodes[object_id].options['color'] = 'yellowgreen'
+    end
   end
 
   ##
-  # Adds +target+ to the graph.
+  # Adds +target+ plus ascendants to graph
+
+  def add_ascendants(target)
+    ascendants = []
+    stack = [target]
+
+    while stack.length > 0
+      o_target = stack.pop
+      ascendants << o_target
+
+      GC.start
+      ObjectSpace.each_object do |object|
+        next if @nodes.key? object.object_id
+        next if object.equal? o_target
+        next if object.equal? ascendants
+        next if object.equal? stack
+        next if ascendants.any? { |x| x.equal? object }
+
+        case object
+        when IO, String, ARGF then
+          # Do nothing
+        when Hash then
+          object.each do |k,v|
+            if k.equal?(o_target) || v.equal?(o_target)
+              stack << object
+              break
+            end
+          end
+        when Enumerable then
+          object.each do |v|
+            if v.equal?(o_target)
+              stack << object
+              break
+            end
+          end
+        end
 
-  def add(target)
-    return if @seen_hash.key? object_name(target)
+        if object.instance_variables.length > 0
+          stack << object if object.instance_variables.any? do |iv_sym|
+            object.instance_variable_get(iv_sym).equal?(o_target)
+          end
+        end
+      end
+    end
+
+    add_object_to_graph(target, { :style => 'dashed' })
+    (ascendants - [target]).each { |x| add_object_to_graph(x) }
+    ascendants.clear
+    stack.clear
+  end
+
+  ##
+  # Adds +target+ to the graph, descending in to the target
 
-    @stack << target
+  def add_descendants(target)
+    stack = add_object_to_graph(target, { :style => 'dashed' })
 
-    while @stack.length > 0
-      object = @stack.pop
-      @name = object_name object
-      next if @seen_hash.key? @name
-      @seen_hash[@name] = 1
+    while stack.length > 0
+      object = stack.pop
+      next if @nodes.key? object.object_id
       @preprocess_callback.call object if @preprocess_callback
 
-      @record = []
-      @record << @name
-
-      case object
-      when String then
-        str = object[0..15].gsub(ESCAPE, '\\\\\1').gsub(/[\r\n]/,' ')
-        str << '...' if object.length > 15
-        @record.push "'#{str}'"
-      when Numeric then
-        @record.push object
-      when Hash then
-        if object.respond_to? :empty? and object.empty? then
-          @record.push 'Empty!'
-        else
-          object.each_with_index do |(k,v),i|
-            next if v.nil? && ! @opts[:show_nil]
-            next unless v.class.to_s =~ @opts[:class_filter]
+      stack += add_object_to_graph(object, {:style => 'filled'})
 
-            add_to_record k, v
-          end
+    end
+  end
+
+  ##
+  # Adds +object+ to tree
+ 
+  def add_object_to_graph(object, opts = {})
+    record = Node.new(object.object_id, object_name(object))
+    record.options = opts
+
+    stack = []
+    case object
+    when String then
+      str = object[0..15].gsub(ESCAPE, '\\\\\1').gsub(/[\r\n]/,' ')
+      str << '...' if object.length > 15
+      record.values << "'#{str}'"
+    when Numeric then
+      record.values << object
+    when IO then
+    when Hash then
+      if object.respond_to? :empty? and object.empty? then
+        record.values << 'Empty!'
+      else
+        object.each_with_index do |(k,v),i|
+          next if v.nil? && ! @opts[:show_nil]
+          next unless v.class.to_s =~ @opts[:class_filter]
+
+          stack += add_to_record(record, k, v)
         end
-      when Enumerable then
-        if object.respond_to? :empty? and object.empty? then
-          @record.push 'Empty!'
-        else
-          object.each_with_index do |v, i|
-            next if v.nil? && ! @opts[:show_nil]
-            if v.class.to_s =~ @opts[:class_filter] or
-               (v.is_a? Enumerable and not v.is_a? String) then
-              add_to_record i, v
-            end
+      end
+    when Enumerable then
+      if object.respond_to? :empty? and object.empty? then
+        record.values.push 'Empty!'
+      else
+        object.each_with_index do |v, i|
+          next if v.nil? && ! @opts[:show_nil]
+          if v.class.to_s =~ @opts[:class_filter] or
+             (v.is_a? Enumerable and not v.is_a? String) then
+            stack += add_to_record(record, i, v)
           end
         end
       end
+    end
 
-      # This is a HACK around bug 1345 (I think)
-      if object.class and object.class.ancestors.include? Array and
-         not Enumerable === object then
-        if object.respond_to? :empty? and object.empty? then
-          @record.push 'Empty!'
-        else
-          object.each_with_index do |v, i|
-            next if v.nil? && ! @opts[:show_nil]
-            if v.class.to_s =~ @opts[:class_filter] or
-               (v.is_a? Enumerable and not v.is_a? String) then
-              add_to_record i, v
-            end
+    # This is a HACK around bug 1345 (I think)
+    if object.class and object.class.ancestors.include? Array and
+       not Enumerable === object then
+      if object.respond_to? :empty? and object.empty? then
+        record.values.push 'Empty!'
+      else
+        object.each_with_index do |v, i|
+          next if v.nil? && ! @opts[:show_nil]
+          if v.class.to_s =~ @opts[:class_filter] or
+             (v.is_a? Enumerable and not v.is_a? String) then
+            stack += add_to_record(record, i, v)
           end
         end
       end
+    end
 
-      add_ivars object
+    stack += add_ivars(record, object)
 
-      @seen_objects.push @record
-    end
+    @nodes[record.node_id] = record
+    stack
   end
 
   ##
   # Adds ivars for +object+ to the graph.
 
-  def add_ivars(object)
+  def add_ivars(record, object)
     return unless object.instance_variables # HACK WTF Rails?
+    stack = []
 
     ivars = object.instance_variables.sort
 
@@ -172,48 +278,52 @@ class ObjectGraph
           next if v.nil? && ! @opts[:show_nil]
           next unless v.class.to_s =~ @opts[:class_filter]
 
-          add_to_record k, v
+          stack += add_to_record(record, k, v)
         end
       end
     end
 
-    ivars.each_with_index do |iv_sym, i|
+    ivars.each do |iv_sym|
       iv = object.instance_variable_get iv_sym
       next if iv.nil? && ! @opts[:show_nil]
       if iv.class.to_s =~ @opts[:class_filter] ||
         (object.is_a?(Enumerable) && !object.is_a?(String))
-        index = @opts[:show_ivars] ? @record.length + i : nil
-        @object_links << [@name, object_name(iv), index]
-        @stack.push(iv)
+
+        obj_name = object_name(iv)
+        record.pointers["#{iv_sym}"] << Pointer.new(obj_name, iv.object_id)
+        record.values.push("#{iv_sym}")
+        stack.push(iv)
       end
     end
 
-    @record.push(*ivars) if @opts[:show_ivars]
+    stack
   end
 
   ##
-  # Adds +key+ and +value+ to the record for the object currently being
-  # processed.
+  # Adds +key+ and +value+ to +record+
 
-  def add_to_record(key, value)
-    @record.push(
+  def add_to_record(record, key, value)
+    stack = []
+    record.values.push(
       [key, value].map { |val|
         case val
         when NilClass
           'nil'
         when Fixnum
           "#{val}"
-        when String
+        when String, Symbol
+          val = ":#{val}" if val.is_a? Symbol
           string_val = val[0..12].gsub(ESCAPE, '\\\\\1').gsub(/[\r\n]/, ' ')
           string_val << '...' if val.length > 12
           string_val
         else
           string_val = object_name val
-          @object_links.push [@name, string_val, @record.length]
-          @stack.push val
+          record.pointers[string_val] << Pointer.new(string_val, val.object_id)
+          stack.push val
           string_val
         end
       }.join(' is '))
+    stack
   end
 
   ##
@@ -261,24 +371,80 @@ digraph g {
 
 END
 
-    @seen_objects.each { |id, *rest|
-      s << "\"#{id}\" [\n\tlabel="
+    @nodes.values.sort.each do |node|
+      s << "\"#{node.name}\" [\n\tlabel="
       list = []
-      [id, *rest].each_with_index { |field, i|
-        list << "<f#{i}>#{field}"
-      }
+      list << "<f0>#{node.name}"
+      node.values.each_with_index do |value,i|
+        list << "<f#{i + 1}>#{value}"
+      end
       s << "\"#{list.join('|')}\"\n"
+      node.options.each do |k,v|
+        s << "#{k}=#{v}\n"
+      end
       s << "\tshape = \"record\"\n]\n\n"
-    }
+    end
 
-    @object_links.each_with_index { |(from, to, x), i|
-      s << "\"#{from}\":f#{x || 0} -> \"#{to}\":f0 [ id = #{i} ]\n"
-    }
+    @nodes.values.each do |node|
+      node.pointers.each_with_index do |(from,pointer),i|
+        pointer.each do |p|
+          to = @nodes[p.object_id]
+          next unless to
+          s<< "\"#{node.name}\":f#{i + 1} -> \"#{p.name}\":f0 [ id = #{i}\n"
+          p.options.each do |k,v|
+            s << "#{k}=#{v}\n"
+          end
+          s << "]\n"
+        end
+      end
+      node.lost_links.each do |p|
+        s<< "\"#{node.name}\":f0 -> \"#{p.name}\":f0 [\n"
+        p.options.each do |k,v|
+          s << "#{k}=#{v}\n"
+        end
+        s << "]\n"
+      end
+    end
 
     s << "}\n"
 
     s
   end
 
+  class Pointer
+    attr_accessor :name, :object_id, :options
+    def initialize(name, object_id, options = {})
+      @name       = name
+      @object_id  = object_id
+      @options    = options
+    end
+
+    def hash
+      name.hash
+    end
+
+    def eql?(other)
+      name.eql? other.name
+    end
+  end
+
+  class Node
+    include Comparable
+    attr_accessor :node_id, :name, :values, :pointers, :options, :lost_links
+
+    def initialize(node_id, name)
+      @node_id  = node_id
+      @name     = name
+      @values   = []
+      @pointers = Hash.new { |h,k| h[k] = [] }
+      @options  = {}
+      @lost_links = []
+    end
+
+    def <=>(other)
+      self.node_id <=> other.node_id
+    end
+  end
+
 end
 

data/test/test_all.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'ograph'
+
+class FooTest < Test::Unit::TestCase
+  def test_foo
+    a = ObjectGraph::Pointer.new(1234, 'asdfasdf')
+    b = ObjectGraph::Pointer.new(1234, 'asdfasdf')
+    assert_equal(true, a.eql?(b))
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ograph
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-02-06 00:00:00 -08:00
+  version: 0.2.0
+date: 2007-06-17 00:00:00 -07:00
 summary: ObjectGraph will output Graphviz dot files of your objects in memory.  It will ferret out your instance variables and enumerate over your enumerables to give you a graph of your object and its relationships.
 require_paths: 
   - lib
@@ -15,6 +15,7 @@ description: "ObjectGraph will output Graphviz dot files of your objects in memo
   ferret out your instance variables and enumerate over your enumerables to give
   you a graph of your object and its relationships.  For sample output and more
   sample code see:  * http://flickr.com/photos/aaronp/tags/graphviz/ *
+  http://tenderlovemaking.com/2007/06/17/graphing-ruby-objects/ *
   http://tenderlovemaking.com/2007/01/13/graphing-objects-in-memory-with-ruby/"
 autorequire: 
 default_executable: 
@@ -38,8 +39,13 @@ files:
   - Manifest.txt
   - README.txt
   - Rakefile
+  - examples/ascendants_graph.rb
+  - examples/diff_graph.rb
+  - examples/regular_graph.rb
   - lib/ograph.rb
-test_files: []
+  - test/test_all.rb
+test_files: 
+  - test/test_all.rb
 rdoc_options: []
 extra_rdoc_files: []
 executables: []
@@ -54,5 +60,5 @@ dependencies:
         - 
           - ">="
           - !ruby/object:Gem::Version 
-            version: 1.1.7
+            version: 1.2.0
       version: