drx 0.0.1

data/README

@@ -0,0 +1,13 @@
+= Dr. X, the Good Doctor
+
+Doctor X is a utility for programmers who wish to understand Ruby's
+object model better. It's a small 'gem' that exposes, in a Tk GUI,
+almost everything about a Ruby object: its 'klass', 'super', 'iv_tbl',
+'m_tbl'. See your singletons with your very own eyes!
+
+== Usage
+
+This section is yet to be written. In the meanwhile, visit the homepage
+to see usage example:
+
+  http://drx.rubyforge.org/

data/ext/drx_ext.c

@@ -0,0 +1,138 @@
+#include "ruby.h"
+#include "st.h"
+
+// Helper for t_get_iv_tbl().
+int record_var(st_data_t key, st_data_t value, VALUE hash) {
+  // I originally did the following, but it breaks for object::Tk*. Perhaps these
+  // values are T_NODEs? (e.g. aliases) @todo: debug using INT2FIX(TYPE(value)).
+  rb_hash_aset(hash, ID2SYM(key), value);
+  // So...
+  rb_hash_aset(hash, ID2SYM(key), Qtrue);
+  return ST_CONTINUE;
+}
+
+/**
+ * Gets the iv_tbl of the object, as a Ruby hash.
+ */
+static VALUE t_get_iv_tbl(VALUE self, VALUE obj)
+{
+  VALUE hash;
+  hash = rb_hash_new();
+
+  if (TYPE(obj) != T_OBJECT && TYPE(obj) != T_CLASS && TYPE(obj) != T_ICLASS && TYPE(obj) != T_MODULE) {
+    rb_raise(rb_eTypeError, "Only T_OBJECT/T_CLASS/T_MODULE is expected as the argument (got %d)", TYPE(obj));
+  }
+  
+  if (ROBJECT(obj)->iv_tbl) {
+    st_foreach(ROBJECT(obj)->iv_tbl, record_var, (st_data_t)hash);
+  }
+
+  return hash;
+}
+
+/**
+ * Extracts one varibale from an object iv_tbl.
+ */
+static VALUE t_get_ivar(VALUE self, VALUE obj, VALUE var_name)
+{
+  const char *c_name;
+  if (TYPE(obj) != T_OBJECT && TYPE(obj) != T_CLASS && TYPE(obj) != T_ICLASS && TYPE(obj) != T_MODULE) {
+    rb_raise(rb_eTypeError, "Only T_OBJECT/T_CLASS/T_MODULE is expected as the argument (got %d)", TYPE(obj));
+  }
+  c_name = StringValuePtr(var_name);
+  return rb_iv_get(obj, c_name);
+}
+
+/**
+ * Returns a class's super.
+ *
+ * In contrast to Class#superclass, this function doesn't skip singletons and T_ICLASS.
+ */
+static VALUE t_get_super(VALUE self, VALUE obj)
+{
+  VALUE super;
+  if (TYPE(obj) != T_CLASS && TYPE(obj) != T_ICLASS && TYPE(obj) != T_MODULE) {
+    rb_raise(rb_eTypeError, "Only T_CLASS/T_MODULE is expected as the argument (got %d)", TYPE(obj));
+  }
+  return RCLASS(obj)->super ? RCLASS(obj)->super : Qnil;
+}
+
+/**
+ * Returns an object's klass.
+ *
+ * In contrast to Object#class, this function doesn't skip singletons and T_ICLASS.
+ */
+static VALUE t_get_klass(VALUE self, VALUE obj)
+{
+  return CLASS_OF(obj);
+  // Note: we can't simply do 'RBASIC(obj)->klass', because obj may be an 'immediate'.
+}
+
+/**
+ * Returns an object's flags.
+ */
+static VALUE t_get_flags(VALUE self, VALUE obj)
+{
+  return INT2NUM(RBASIC(obj)->flags);
+}
+
+// Helper for t_get_m_tbl().
+int record_method(st_data_t key, st_data_t value, VALUE hash) {
+  // @todo: Store something useful in the values.
+  rb_hash_aset(hash, key == ID_ALLOCATOR ? rb_str_new2("<Allocator>") : ID2SYM(key), INT2FIX(666));
+  return ST_CONTINUE;
+}
+
+/**
+ * Gets the m_tbl of a class.
+ */
+static VALUE t_get_m_tbl(VALUE self, VALUE obj)
+{
+  VALUE hash;
+
+  if (TYPE(obj) != T_CLASS && TYPE(obj) != T_ICLASS && TYPE(obj) != T_MODULE) {
+    rb_raise(rb_eTypeError, "Only T_CLASS/T_MODULE is expected as the argument (got %d)", TYPE(obj));
+  }
+
+  hash = rb_hash_new();
+  st_foreach(RCLASS(obj)->m_tbl, record_method, (st_data_t)hash);
+  return hash;
+}
+
+/**
+ * Returns the object's "id".
+ *
+ * This is an alternative to Object#__id__ because the latter doesn't
+ * work for T_ICLASS.
+ */
+static VALUE t_get_address(VALUE self, VALUE obj)
+{
+  return INT2NUM(obj);
+}
+
+/**
+ * Gets the Ruby's engine type of a variable.
+ */
+static VALUE t_get_type(VALUE self, VALUE obj)
+{
+  return INT2NUM(TYPE(obj));
+}
+
+VALUE mDrx;
+
+void Init_drx_ext() {
+  mDrx = rb_define_module("Drx");
+  rb_define_module_function(mDrx, "get_iv_tbl", t_get_iv_tbl, 1);
+  rb_define_module_function(mDrx, "get_m_tbl", t_get_m_tbl, 1);
+  rb_define_module_function(mDrx, "get_super", t_get_super, 1);
+  rb_define_module_function(mDrx, "get_klass", t_get_klass, 1);
+  rb_define_module_function(mDrx, "get_flags", t_get_flags, 1);
+  rb_define_module_function(mDrx, "get_address", t_get_address, 1);
+  rb_define_module_function(mDrx, "get_type", t_get_type, 1);
+  rb_define_module_function(mDrx, "get_ivar", t_get_ivar, 2);
+  rb_define_const(mDrx, "FL_SINGLETON", INT2FIX(FL_SINGLETON));
+  rb_define_const(mDrx, "T_OBJECT", INT2FIX(T_OBJECT));
+  rb_define_const(mDrx, "T_CLASS", INT2FIX(T_CLASS));
+  rb_define_const(mDrx, "T_ICLASS", INT2FIX(T_ICLASS));
+  rb_define_const(mDrx, "T_MODULE", INT2FIX(T_MODULE));
+}

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("drx_ext")

data/lib/drx.rb

@@ -0,0 +1,67 @@
+require 'drx_ext' # Load the C extension
+
+# Contains a simple utility function, Drx::examine.
+
+module Drx
+
+  def self.obj_repr(obj)
+    is_singleton = Drx.is_class_like(obj) && (Drx.get_flags(obj) & Drx::FL_SINGLETON).nonzero?
+    is_iclass    = Drx.get_type(obj) == Drx::T_ICLASS
+    if is_iclass
+      return "'ICLS { include " + obj_repr(Drx.get_klass(obj)) + " }"
+    else
+      return obj.inspect + (is_singleton ? " 'S" : "")
+    end
+  end
+
+  def self.examine(obj, level = 0, title = '', &block) # :yield:
+    # Note: since 'obj' may be a T_ICLASS, it doesn't repond to may methods,
+    # including is_a?. So when we're querying things we're using Drx calls
+    # instead.
+
+    $seen = {} if level.zero?
+    line = ('  ' * level) + title + ' ' + obj_repr(obj)
+
+    address = Drx.get_address(obj)
+    seen = $seen[address]
+    $seen[address] = true
+    
+    if seen
+      line += " [seen]" #  #{address.to_s}"
+    end
+
+    if block_given?
+      yield line, obj
+    else
+      puts line
+    end
+    
+    return if seen
+
+    if Drx.is_class_like(obj)
+      # Kernel has a NULL super.
+      # Modules too have NULL super, unless when 'include'ing.
+      if Drx.get_super(obj) # Warning: we can't do 'if !Drx.get_super(obj).#nil?' because
+                            # T_ICLASS doesn't "have" #nil.
+        Drx.examine(Drx.get_super(obj), level+1, '[super]', &block)
+      end
+    end
+
+    # Dipslaying a T_ICLASS's klass isn't very useful, because the data
+    # is already mirrored in the m_tbl and iv_tvl of the T_ICLASS itself.
+    if Drx.get_type(obj) != Drx::T_ICLASS
+      Drx.examine(Drx.get_klass(obj), level+1, '[klass]', &block)
+    end
+  end
+
+  def self.has_iv_tbl(obj)
+    Drx.get_type(obj) == T_OBJECT or Drx.is_class_like(obj)
+  end
+
+  # Returns true if this object is either a class or a module.
+  # When true, you know it has 'm_tbl' and 'super'.
+  def self.is_class_like(obj)
+    [Drx::T_CLASS, Drx::T_ICLASS, Drx::T_MODULE].include? Drx.get_type(obj)
+  end
+
+end

data/lib/drx_test.rb

@@ -0,0 +1,25 @@
+require 'drxtk'
+
+require 'date'
+
+##############################
+
+class Zeman < DateTime
+  def int
+  end
+end
+
+zmn = Zeman.new
+
+def zmn.koko
+ 9090
+end
+
+Drx.examine(zmn)
+
+#############################
+
+Drx.examinetk(zmn)
+
+#Drx.examinetk(zmn)
+#Drx.examinetk("some_string")

data/lib/drx_test2.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'dm-core'
+
+class Post
+  include DataMapper::Resource
+ 
+  property :post_id,  Integer, :serial => true
+  property :title,    String
+  property :body,     Text
+  
+  belongs_to :user
+end
+
+class User
+  include DataMapper::Resource
+ 
+  property :user_uid,  Integer, :serial => true
+  property :name,      String
+  property :mail,      String
+end
+
+post = Post.new
+
+require 'drxtk'
+Drx.see(post)

data/lib/drxtk.rb

@@ -0,0 +1,126 @@
+require 'drx'
+require 'tk'
+
+module Drx
+  def self.examinetk(obj)
+    app = Drx::TkGUI::DrxWindow.new
+    app.display_value(obj)
+    app.run
+  end
+
+  # easier to type...
+  def self.see(obj)
+    examinetk(obj)
+  end
+end
+
+module Drx
+  module TkGUI
+
+    class ScrolledListbox < TkFrame
+      def initialize(*args, &block)
+        super(*args, &block)
+        @the_list = the_list = TkListbox.new(self) {
+          #pack :side => 'left'#, :expand => 'true', :fill => 'both'
+        }
+        TkScrollbar.new(self) { |s|
+          pack :side => 'right', :fill => 'y'
+          command { |*args| the_list.yview *args }
+          the_list.yscrollcommand { |first,last| s.set first,last }
+        }
+        TkScrollbar.new(self) { |s|
+          orient 'horizontal'
+          pack :side => 'bottom', :fill => 'x'
+          command { |*args| the_list.xview *args }
+          the_list.xscrollcommand { |first,last| s.set first,last }
+        }
+        @the_list.pack(:side => 'left', :expand => 'true', :fill => 'both')
+      end
+      def the_list
+        @the_list
+      end
+    end
+
+    class ::TkListbox
+      def get_selection
+        idx = curselection[0]
+        return get(idx)
+      end
+      def get_index
+        curselection[0]
+      end
+    end
+
+    class DrxWindow
+      def initialize
+        root = TkRoot.new
+        @list = (ScrolledListbox.new(root) {
+          #pack :side => 'left', :fill => 'y'
+          pack :side => 'left', :fill => 'both', :expand => true
+        }).the_list
+        @list.width 52
+        @list.height 25
+        @list.focus
+        @varsbox = (ScrolledListbox.new(root) {
+          #pack :side => 'left', :fill => 'y'
+          pack :side => 'left', :fill => 'both', :expand => true
+        }).the_list
+        @methodsbox = (ScrolledListbox.new(root) {
+          #pack :side => 'left', :fill => 'y'
+          pack :side => 'left', :fill => 'both', :expand => true
+        }).the_list
+
+        @list.bind('<ListboxSelect>') {
+          @current_object = @objs[@list.get_index]
+          display_variables(current_object)
+          display_methods(current_object)
+        }
+        @varsbox.bind('<ListboxSelect>') {
+          inspect_variable(current_object, @varsbox.get_selection)
+        }
+      end
+
+    #  def current_object=(obj)
+    #    @current_object = obj
+    #  end
+      
+      def current_object
+        @current_object
+      end
+
+      def display_variables(obj)
+        @varsbox.delete('0', 'end')
+        if (Drx.has_iv_tbl(obj)) 
+          vars = Drx.get_iv_tbl(obj).keys.map do |v| v.to_s end.sort
+          @varsbox.insert('end', *vars)
+        end
+      end
+      
+      def inspect_variable(obj, var_name)
+        print "\n== Variable #{var_name}\n\n"
+        p Drx.get_ivar(obj, var_name)
+      end
+      
+      def display_methods(obj)
+        @methodsbox.delete('0', 'end')
+        if (Drx.is_class_like(obj)) 
+          methods = Drx.get_m_tbl(obj).keys.map do |v| v.to_s end.sort
+          @methodsbox.insert('end', *methods)
+        end
+      end
+      
+      def display_value(value)
+        @objs = []
+        Drx.examine(value) do |line, obj|
+          @list.insert('end', line)
+          @objs << obj
+        end
+      end
+      
+      def run
+        Tk.mainloop
+      end
+    end
+
+  end # module TkGUI
+end # module Drx

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: drx
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mooffie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-03 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mooffie@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/drxtk.rb
+- lib/drx_test2.rb
+- lib/drx_test.rb
+- lib/drx.rb
+- ext/extconf.rb
+- ext/drx_ext.c
+has_rdoc: false
+homepage: http://drx.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: "1.8"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: drx
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Inspect Ruby objects.
+test_files: []
+