RuTu 0.0.1

data/README

@@ -0,0 +1 @@
+ruby sample.rb | dot -Tgif > sample.gif

data/ext/RuTuExt.c

@@ -0,0 +1,144 @@
+#include "ruby.h"
+#include "st.h"
+
+#include <assert.h>
+/*
+struct RBasic {
+    unsigned long flags;
+    VALUE klass;
+};
+struct RObject {
+    struct RBasic basic;
+    struct st_table *iv_tbl;
+};
+struct RClass {
+    struct RBasic basic;
+    struct st_table *iv_tbl;
+    struct st_table *m_tbl;
+    VALUE super;
+};
+*/
+
+
+
+VALUE RuTuExt__obj_id(VALUE dummy, VALUE v)
+{
+	return rb_obj_id(v);
+}
+VALUE RuTuExt__equal(VALUE dummy, VALUE v1, VALUE v2) // rb_obj_equal
+{
+        if (v1 == v2) return Qtrue;
+        return Qfalse;
+}
+VALUE RuTuExt__klass(VALUE dummy, VALUE self)
+{
+	return RBASIC(self)->klass;
+}
+VALUE RuTuExt__iv_tbl(VALUE dummy, VALUE obj)
+{
+	//return rb_fix_new(RCLASS(klass)->m_tbl);
+        //assert((RCLASS(klass)->m_tbl & 1) == 0); // doesn't matter......
+	return (VALUE) ROBJECT(obj)->iv_tbl; // note: can't be inspected
+}
+VALUE RuTuExt__m_tbl(VALUE dummy, VALUE klass)
+{
+	//return rb_fix_new(RCLASS(klass)->m_tbl);
+        //assert((RCLASS(klass)->m_tbl & 1) == 0); // doesn't matter......
+	return (VALUE) RCLASS(klass)->m_tbl; // note: can't be inspected
+}
+VALUE RuTuExt__super(VALUE dummy, VALUE klass)
+{
+	return RCLASS(klass)->super;
+}
+VALUE RuTuExt__singleton_class(VALUE dummy, VALUE klass)
+{
+        if (FL_TEST(klass, FL_SINGLETON)) return Qtrue;
+        return Qfalse;
+}
+
+
+
+VALUE RuTuExt__class_path(VALUE obj, VALUE klass)
+{
+	return rb_class_path(klass);
+}
+//VALUE RuTuExt_class2name(VALUE klass)
+//{
+//	return rb_class2name(klass);
+//}
+
+//int myprint(ID id, VALUE value, st_data_t dummy)
+//{
+//	printf("myprint: %d %s\n", id, rb_id2name(id));
+//	return ST_CONTINUE;
+//}
+//
+//int myprint_m_tbl_entry(ID id, VALUE value, st_data_t dummy)
+//{
+//	printf("myprint_m_tbl_entry: %d %s %s\n", id, rb_id2name(id), rb_obj_classname(value));
+//	return ST_CONTINUE;
+//}
+
+/*
+VALUE RuTuExt_foo(VALUE obj, VALUE x)
+{
+	//printf("rb_obj_classname of obj: %s\n", rb_obj_classname(obj));
+	printf("x: %ld\n", x);
+	printf("klass: %ld\n", RBASIC(x)->klass);
+	printf("iv_tbl: %ld\n", ROBJECT(x)->iv_tbl);
+	printf("m_tbl: %ld\n", RCLASS(x)->m_tbl);
+	printf("===== each iv_tbl\n");
+	st_foreach(ROBJECT(x)->iv_tbl, myprint, (st_data_t) NULL);
+	printf("===== each m_tbl\n");
+	st_foreach(RCLASS(x)->m_tbl, myprint_m_tbl_entry, (st_data_t) NULL);
+	return x;
+}
+*/
+
+//VALUE RuTuExt_class_show_methods(VALUE module, VALUE klass)
+//{
+//	while (klass)
+//	{
+//		//printf("klass: %ld %s======\n", klass, RSTRING(rb_class_name(klass))->ptr);
+//		//printf("klass: %ld %s======\n", klass, rb_class2name(klass));
+//		printf("klass: %ld %s======\n", klass, RSTRING(rb_class_path(klass))->ptr);
+//		//st_foreach(ROBJECT(klass)->iv_tbl, myprint, (st_data_t) NULL);
+//		printf("--\n");
+//		st_foreach(RCLASS(klass)->m_tbl, myprint_m_tbl_entry, (st_data_t) NULL);
+//		klass = RCLASS(klass)->super;
+//	}
+//	return klass;
+//}
+//
+//
+//VALUE RuTuExt_obj_show_methods(VALUE module, VALUE obj)
+//{
+//	return RuTuExt_class_show_methods(module, CLASS_OF(obj));
+//}
+//
+//VALUE RuTuExt_class_instance_methods(VALUE dummy, VALUE klass)
+//{
+//	return rb_class_instance_methods(0, NULL, klass);
+//}
+
+
+void Init_RuTuExt()
+{
+	VALUE mRuTuExt;
+	mRuTuExt = rb_define_module("RuTuExt");
+//	printf("hihi\n");
+	rb_define_module_function(mRuTuExt, "_obj_id", RuTuExt__obj_id, 1);
+	rb_define_module_function(mRuTuExt, "_equal?", RuTuExt__equal, 2);
+	rb_define_module_function(mRuTuExt, "_klass", RuTuExt__klass, 1);
+	rb_define_module_function(mRuTuExt, "_iv_tbl", RuTuExt__iv_tbl, 1);
+	rb_define_module_function(mRuTuExt, "_m_tbl", RuTuExt__m_tbl, 1);
+	rb_define_module_function(mRuTuExt, "_super", RuTuExt__super, 1);
+	rb_define_module_function(mRuTuExt, "_class_path", RuTuExt__class_path, 1);
+	//rb_define_module_function(mRuTuExt, "_instance_methods", RuTuExt_class_instance_methods, 1);
+	rb_define_module_function(mRuTuExt, "_singleton_class?", RuTuExt__singleton_class, 1);
+/*
+	rb_define_module_function(mRuTuExt, "foo", RuTuExt_foo, 1);
+	rb_define_module_function(mRuTuExt, "RuTuExt_obj_show_methods", RuTuExt_obj_show_methods, 1);
+	rb_define_module_function(mRuTuExt, "RuTuExt_class_show_methods", RuTuExt_class_show_methods, 1);
+*/
+}

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("RuTuExt")

data/lib/RuTu.rb

@@ -0,0 +1,205 @@
+require "set"
+require "RuTuExt"
+require "cgi"
+
+module RuTu
+
+class ValueNode
+  def initialize(g, v)
+    @graph = g
+    @value = v
+  end
+  def same_value?(v)
+    RuTuExt._equal?(@value, v)
+  end
+  def _obj_id
+    RuTuExt._obj_id(@value)
+  end
+  def walk(new_value, node_class, relation)
+    n = @graph.add(new_value, node_class)
+    @graph.add_edge(self, n, relation)
+    n
+  end
+
+  def node_id
+    "node#{ _obj_id() }"
+  end
+  def fields
+    [ :header ]
+  end
+  def header_value
+    [ self.class.name.gsub(/.*::/, ''), _obj_id() ] 
+  end
+  def color
+    "black"
+  end
+  def to_dot
+    label = fields().map do |f|
+      v = self.respond_to?("#{f}_value") ? self.send("#{f}_value") : f
+      v = [ v ].flatten.map { |x| CGI.escapeHTML(x.to_s()) }.join("<br/>")
+      %Q! <tr><td port="#{f}">#{v}</td></tr> ! 
+    end.join(" ")
+    label = "<table>#{label}</table>"
+    node_id() + " [ shape=plaintext, color=#{color()}, label=<#{label}> ]"
+  end
+end
+
+class RBasicNode < ValueNode
+  def flags; end
+  def _klass
+    RuTuExt._klass(@value)
+  end
+  def klass
+    walk(_klass(), RClassNode, "klass")
+  end
+  def fields
+    super() + [ :flags, :klass ] 
+  end
+end
+
+class RObjectNode < RBasicNode
+  def _iv_tbl
+    RuTuExt._iv_tbl(@value)
+  end
+  def iv_tbl
+    walk(_iv_tbl(), St_TableNode, "iv_tbl")
+  end
+  def fields
+    super() + [ :iv_tbl ]
+  end
+  def color
+    "yellow"
+  end
+end
+
+class RClassNode < RObjectNode
+  def header_value
+    [ super(), RuTuExt._class_path(@value) ]
+  end
+  def _m_tbl
+    RuTuExt._m_tbl(@value)
+  end
+  def m_tbl
+    walk(_m_tbl(), St_TableNode, "m_tbl")
+  end
+  def _super
+    RuTuExt._super(@value)
+  end
+  def super
+    walk(_super(), RClassNode, "super")
+  end
+  alias :zuper :super
+  def fields
+    super() + [ :m_tbl, :super ]
+  end
+  def color
+    "red"
+  end
+end
+
+class NotValueNode < ValueNode
+  def inspect
+    "i was never here"
+  end
+end
+
+class St_TableNode < NotValueNode
+end
+
+
+class NullNode < ValueNode
+end
+
+
+
+
+class Edge
+  def initialize(from, to, relation, options = {})
+    @from, @to, @relation, @options = from, to, relation, options
+  end
+  def same?(from, to, relation)
+    @from == from && @to == to && @relation == relation
+  end
+  def to_dot(to_set)
+    "#{@from.node_id}:#{@relation} -> #{@to.node_id}:header [ label = #{@relation} ]" + 
+    ((@relation == "klass" && to_set.add?(@to)) ? "{ rank = same; #{@from.node_id}; #{@to.node_id}; }" : "")
+  end
+end
+
+class Graph
+  def initialize
+    @nodes = [] #Set.new
+    @edges = [] #Set.new
+  end
+
+  def add(value, node_class)
+    rtn = @nodes.find { |n| n.same_value?(value) }
+    if not rtn
+      node_class = NullNode if false == value
+      rtn = node_class.new(self, value)
+      @nodes << rtn
+    end
+    rtn
+  end
+  def add_edge(from, to, relation)
+    rtn = @edges.find { |e| e.same?(from, to, relation) }
+    if not rtn
+      rtn = Edge.new(from, to, relation)
+      @edges << rtn
+    end
+    rtn
+  end
+
+  # depth = 0 => no-op
+  # depth = -1 => no limit
+  def closure(init_nodes, relations, depth = -1)
+    nodes = Array.new init_nodes
+    s = 0
+    e = nodes.size
+    while s < e && depth != 0
+      for i in (s ... e) do
+        relations.each do |r|
+          nodes |= [ nodes[i].send(r) ] if nodes[i].respond_to?(r)
+        end
+      end
+      depth = depth - 1
+      s = e
+      e = nodes.size 
+    end
+    nodes
+  end
+
+  def to_dot
+    to_set = Set.new
+    return <<-"EOG"
+digraph G {
+#    rankdir=LR
+    node [fontname=Luxi]
+    edge [fontname=Luxi]
+      #{ @nodes.map { |n| n.to_dot + "\n" } }
+      #{ @edges.map { |e| e.to_dot(to_set) + "\n" } }
+}
+EOG
+  end
+end
+
+end
+__END__
+
+#module M; end
+#class A
+#  include M
+#end
+#a = A.new
+#def a.foo; end
+#
+class A
+end
+a = A.new
+
+
+
+g = Graph.new
+a_ = g.add(a, RObjectNode)
+g.closure([ a_.klass ], [:klass, :super])
+puts g.to_dot

data/sample.rb

@@ -0,0 +1,12 @@
+require "rubygems"
+require "RuTu"
+
+class A
+end
+a = A.new
+
+
+g = RuTu::Graph.new
+a_ = g.add(a, RuTu::RObjectNode)
+g.closure([ a_.klass ], [:klass, :super])
+puts g.to_dot

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: RuTu
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-06-03 00:00:00 +00:00
+summary: a tool for visualizing object graphs
+require_paths: 
+- lib
+email: 
+homepage: lcamel@gmail.com
+rubyforge_project: rutu
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Luoh Ren-Shan
+files: 
+- lib/RuTu.rb
+- ext/RuTuExt.c
+- ext/extconf.rb
+- sample.rb
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: 
+- "\"dot\" in the GraphViz package"
+dependencies: []
+