ograph 0.0.1 → 0.1.0

data/History.txt

@@ -1,3 +1,15 @@
+== 0.1.0
+
+Tons of changes thanks to Eric Hodel!
+
+* ObjectGraph is now an instance so you can add more stuff to it
+* Key Value pairs in Hashes are now listed in the hash box
+* String values are displayed
+* ObjectGraph knows how to handle ActiveRecord objects
+* Labels are now ObjectID-ClassName
+* Empty arrays or hashes will say that they are empty
+* Much much more!
+
 == 0.0.1 / 2007-01-14
 
 * Birthday!

data/README.txt

@@ -16,9 +16,7 @@ For sample output and more sample code see:
 
 == PROBLEMS
 
-The output graph kind of lies when displaying Hashes.  A Hash will point to
-an Array with a key and value.  If the hash contains 7 pairs, it will point
-to 7 Arrays.
+None currently known.
 
 == SYNOPSYS
 

data/Rakefile

@@ -3,7 +3,7 @@ require 'hoe'
 require './lib/ograph.rb'
 
 Hoe.new('ograph', ObjectGraph::VERSION) do |p|
-  p.rubyforge_name  = 'ograph'
+  p.rubyforge_name  = 'seattlerb'
   p.author          = 'Aaron Patterson'
   p.email           = 'aaronp@rubyforge.org'
   p.summary         = p.paragraphs_of('README.txt', 3).join("\n\n")

data/lib/ograph.rb

@@ -1,72 +1,284 @@
+##
+# ObjectGraph creates a dot file that represents the connections between your
+# Objects.  ObjectGraph knows about Hash, Enumerable, instance variables and
+# ActiveRecord::Base to create the prettiest graphs possible.
+#
+# Here's an example that graphs the fixtures of a Rails application.  Run
+# `rake db:test:prepare` beforehand.
+#
+#   ENV['RAILS_ENV'] = 'test'
+#   require 'config/environment'
+#   require 'ograph'
+#   
+#   ar_descendents = []
+#   ObjectSpace.each_object Class do |klass|
+#     ar_descendents << klass if klass < ActiveRecord::Base
+#   end
+#   
+#   File.open 'world.dot', 'w' do |fp|
+#     graph = ObjectGraph.new
+#   
+#     graph.preprocess_callback do |object|
+#       next unless ActiveRecord::Base === object
+#   
+#       object.class.reflect_on_all_associations.each do |a|
+#         object.send a.name, true
+#       end
+#     end
+#   
+#     ar_descendents.each do |klass|
+#       next if klass.abstract_class?
+#       begin
+#         klass.find(:all).each do |obj|
+#           graph.add obj
+#         end
+#       rescue => e
+#         puts "#{klass} has problems:\n\t#{e}"
+#       end
+#     end
+#   
+#     fp.write graph
+#   end
+
 class ObjectGraph
-  VERSION = '0.0.1'
+
+  ##
+  # The version of ObjectGraph you are currently using.
+
+  VERSION = '0.1.0'
+
+  ##
+  # Characters we need to escape
+ 
+  ESCAPE = /([<>"\\])/
+
+  ##
+  # Handy-dandy super-friendly graph generator shortcut.
+  #
+  # Just hand it and object and let it rip!  Returns a dot graph.
 
   def self.graph(target, opts = {})
-    opts = {  :class_filter => /./,
-              :show_ivars   => true,
-              :show_nil     => true,
-    }.merge(opts)
-
-    stack         = [target]
-    object_links  = []
-    seen_objects  = []
-    seen_hash     = {}
-
-    while stack.length > 0
-      object = stack.pop
-      next if seen_hash.key? object.object_id
-      seen_hash[object.object_id] = 1
-
-      if object.is_a?(Enumerable) && ! object.is_a?(String)
-        object.each { |iv|
-          next if iv.nil? && ! opts[:show_nil]
-          if iv.class.to_s =~ opts[:class_filter] || object.is_a?(Enumerable)
-            object_links.push([object.object_id, iv.object_id, nil])
-            stack.push(iv)
+    graph = new opts
+    graph.add target
+    graph.to_s
+  end
+
+  ##
+  # Creates a new ObjectGraph instance.  Options may include:
+  #
+  # :class_filter:: Regular expression that matches classes to include.
+  # :show_ivars:: Show instance variables (in the record, edges still get
+  #               drawn.)
+  # :show_nil:: Draw nil (and edges to nil.)
+
+  def initialize(opts = {})
+    defaults = { :class_filter => //, :show_ivars => true, :show_nil => true }
+    @opts = defaults.merge opts
+
+    @stack         = []
+    @object_links  = []
+    @seen_objects  = []
+    @seen_hash     = {}
+
+    @preprocess_callback = nil
+  end
+
+  ##
+  # Adds +target+ to the graph.
+
+  def add(target)
+    return if @seen_hash.key? object_name(target)
+
+    @stack << target
+
+    while @stack.length > 0
+      object = @stack.pop
+      @name = object_name object
+      next if @seen_hash.key? @name
+      @seen_hash[@name] = 1
+      @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]
+
+            add_to_record k, v
           end
-        }
+        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
+        end
       end
 
-      ivars = object.instance_variables.sort
-      ivars.each_with_index do |iv_sym, i|
-        iv = object.instance_variable_get iv_sym
-        next if iv.nil? && ! opts[:show_nil]
-        if iv.class.to_s =~ opts[:class_filter] || iv.is_a?(Enumerable)
-          object_links.push([ object.object_id,
-                              iv.object_id,
-                              opts[:show_ivars] ? i : nil])
-          stack.push(iv)
+      # 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
+          end
         end
       end
 
-      seen_objects.push([ object.object_id,
-                          object.class ] + (opts[:show_ivars] ? ivars : []))
+      add_ivars object
+
+      @seen_objects.push @record
     end
+  end
+
+  ##
+  # Adds ivars for +object+ to the graph.
+
+  def add_ivars(object)
+    return unless object.instance_variables # HACK WTF Rails?
+
+    ivars = object.instance_variables.sort
+
+    if defined? ActiveRecord::Base && ActiveRecord::Base === object then
+      ivars.delete '@attributes'
+      attrs = object.instance_variable_get :@attributes
+
+      unless attrs.nil? then
+        attrs.each_with_index do |(k,v),i|
+          next if v.nil? && ! @opts[:show_nil]
+          next unless v.class.to_s =~ @opts[:class_filter]
 
+          add_to_record k, v
+        end
+      end
+    end
+
+    ivars.each_with_index do |iv_sym, i|
+      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)
+      end
+    end
+
+    @record.push(*ivars) if @opts[:show_ivars]
+  end
+
+  ##
+  # Adds +key+ and +value+ to the record for the object currently being
+  # processed.
+
+  def add_to_record(key, value)
+    @record.push(
+      [key, value].map { |val|
+        case val
+        when NilClass
+          'nil'
+        when Fixnum
+          "#{val}"
+        when String
+          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
+          string_val
+        end
+      }.join(' is '))
+  end
+
+  ##
+  # The name of an Object.  Understands ActiveRecord::Base objects.
+
+  def object_name(object)
+    id = if defined? ActiveRecord::Base and ActiveRecord::Base === object then
+           object.id
+         else
+           object.object_id
+         end
+    "#{id}-#{object.class}"
+  end
+
+  ##
+  # Stores a callback for #add to call on each object it processes before
+  # adding to the graph.
+  #
+  # To add all the associations of an ActiveRecord::Base object:
+  #
+  #   graph.preprocess_callback do |object|
+  #     next unless ActiveRecord::Base === object
+  #   
+  #     object.class.reflect_on_all_associations.each do |a|
+  #       object.send a.name, true
+  #     end
+  #   end
+
+  def preprocess_callback(&block)
+    @preprocess_callback = block
+  end
+
+  ##
+  # Returns dot for the objects added to the graph.  Use GraphViz to turn the
+  # graph into a PNG (or whatever).
+
+  def to_s
     s = <<END
 digraph g {
-    graph [ rankdir = "LR" ];
-    node [ fontsize = "8"
-           shape = "ellipse"
-    ];
-    edge [ ];
+\tgraph [ rankdir = "LR" ];
+\tnode [ fontsize = "8"
+\t\tshape = "ellipse"
+\t];
+\tedge [ ];
+
 END
-    seen_objects.each { |id, *rest|
-      s += "\"#{id}\" [\nlabel="
+
+    @seen_objects.each { |id, *rest|
+      s << "\"#{id}\" [\n\tlabel="
       list = []
       [id, *rest].each_with_index { |field, i|
         list << "<f#{i}>#{field}"
       }
-      s += "\"#{list.join('|')}\"\n"
-      s += <<END
-      shape = "record"
-      ]
-END
+      s << "\"#{list.join('|')}\"\n"
+      s << "\tshape = \"record\"\n]\n\n"
     }
-    object_links.each_with_index { |(from, to, x), i|
-      s += "\"#{from}\":f#{x ? x + 2 : 0} -> \"#{to}\":f0 [ id = #{i} ]\n"
+
+    @object_links.each_with_index { |(from, to, x), i|
+      s << "\"#{from}\":f#{x || 0} -> \"#{to}\":f0 [ id = #{i} ]\n"
     }
-    s += "}\n"
+
+    s << "}\n"
+
     s
   end
+
 end
+

metadata

@@ -3,14 +3,14 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ograph
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-01-20 00:00:00 -08:00
+  version: 0.1.0
+date: 2007-02-06 00:00:00 -08: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
 email: aaronp@rubyforge.org
 homepage: http://seattlerb.rubyforge.org/
-rubyforge_project: ograph
+rubyforge_project: seattlerb
 description: "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.  For sample output and more
@@ -54,5 +54,5 @@ dependencies:
         - 
           - ">="
           - !ruby/object:Gem::Version 
-            version: 1.1.6
+            version: 1.1.7
       version: