drx 0.0.1 → 0.0.2

data/ext/drx_ext.c

@@ -1,6 +1,14 @@
 #include "ruby.h"
 #include "st.h"
 
+/**
+ * Gets the Ruby's engine type of a variable.
+ */
+static VALUE t_get_type(VALUE self, VALUE obj)
+{
+  return INT2NUM(TYPE(obj));
+}
+
 // 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
@@ -78,7 +86,7 @@ static VALUE t_get_flags(VALUE self, VALUE obj)
 
 // 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.
+  // @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;
 }
@@ -110,14 +118,102 @@ static VALUE t_get_address(VALUE self, VALUE obj)
   return INT2NUM(obj);
 }
 
-/**
- * Gets the Ruby's engine type of a variable.
+// {{{ Locating methods
+
+#include "node.h"
+
+#define RSTR(s) rb_str_new2(s)
+
+static t_do_locate_method(NODE *ND_method) {
+  NODE *ND_scope = NULL, *ND_block = NULL;
+  VALUE place;
+  char line_s[20];
+  
+  //
+  // The NODE_METHOD node
+  //
+
+  if (nd_type(ND_method) != NODE_METHOD/*0*/) {
+    return RSTR("I'm expecting a NODE_METHOD here...");
+  }
+  
+  //
+  // The NODE_SCOPE node
+  //
+  
+  ND_scope = ND_method->u2.node;
+
+  if (nd_type(ND_scope) == NODE_CFUNC/*2*/) {
+    return RSTR("That's a C function");
+  }
+  
+  if (nd_type(ND_scope) == NODE_ATTRSET/*89*/) {
+    return RSTR("That's an attr setter");
+  }
+
+  if (nd_type(ND_scope) == NODE_FBODY/*1*/) {
+    return RSTR("That's an alias");
+  }
+  
+  if (nd_type(ND_scope) == NODE_ZSUPER/*41*/) {
+    // @todo The DateTime clas has a lot of these.
+    return RSTR("That's a ZSUPER, whatver the heck it means!");
+  }
+
+  if (nd_type(ND_scope) != NODE_SCOPE/*3*/) {
+    printf("I'm expecting a NODE_SCOPE HERE (got %d instead)\n", nd_type(ND_scope));
+    return RSTR("I'm expecting a NODE_SCOPE HERE...");
+  }
+  
+  //
+  // The NODE_BLOCK node
+  //
+  
+  ND_block = ND_scope->u3.node;
+
+  if (nd_type(ND_block) != NODE_BLOCK/*4*/) {
+    return RSTR("I'm expecting a NODE_BLOCK here...");
+  }
+  
+  sprintf(line_s, "%d:", nd_line(ND_block));
+  place = RSTR(line_s);
+  rb_str_cat2(place, ND_block->nd_file);
+  
+  return place;
+}
+
+/*
+ *  call-seq:
+ *     Drx.locate_method(Date, "to_s")  => str
+ *  
+ *  Locates the filename and line-number where a method was defined. Returns a
+ *  string of the form "89:/path/to/file.rb", or nil if method doens't exist.
+ *  If the method exist but isn't a Ruby method (i.e., if it's written in C),
+ *  the string returned will include an erorr message, e.g. "That's a C
+ *  function".
  */
-static VALUE t_get_type(VALUE self, VALUE obj)
+static VALUE t_locate_method(VALUE self, VALUE obj, VALUE method_name)
 {
-  return INT2NUM(TYPE(obj));
+  const char *c_name;
+  NODE *method_node;
+
+  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));
+  }
+  if (!RCLASS(obj)->m_tbl) {
+    return Qnil;
+  }
+  c_name = StringValuePtr(method_name);
+  ID id = rb_intern(c_name);
+  if (st_lookup(RCLASS(obj)->m_tbl, id, &method_node))  {
+    return t_do_locate_method(method_node);
+  } else {
+    return Qnil;
+  }
 }
 
+// }}}
+
 VALUE mDrx;
 
 void Init_drx_ext() {
@@ -130,6 +226,7 @@ void Init_drx_ext() {
   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_module_function(mDrx, "locate_method", t_locate_method, 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));

data/lib/drx_test.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'drxtk'
 
 require 'date'
@@ -20,6 +21,4 @@ Drx.examine(zmn)
 #############################
 
 Drx.examinetk(zmn)
-
-#Drx.examinetk(zmn)
 #Drx.examinetk("some_string")

data/lib/drxtk.rb

@@ -4,7 +4,7 @@ require 'tk'
 module Drx
   def self.examinetk(obj)
     app = Drx::TkGUI::DrxWindow.new
-    app.display_value(obj)
+    app.see(obj)
     app.run
   end
 
@@ -16,6 +16,9 @@ end
 
 module Drx
   module TkGUI
+   
+    # The 'DRX_EDITOR_COMMAND' environment variable overrides this.
+    EDITOR_COMMAND = 'gedit +%d "%s"'
 
     class ScrolledListbox < TkFrame
       def initialize(*args, &block)
@@ -53,20 +56,26 @@ module Drx
 
     class DrxWindow
       def initialize
+        @stack = []
         root = TkRoot.new
+        @evalbox = TkEntry.new(root) {
+          font 'Courier'
+          pack(:side => 'bottom', :fill => 'both')
+        }
+        TkLabel.new(root, :anchor => 'w') {
+          text 'Type some code to eval in the context of the selected object; prepend with "see" to examine it.'
+          pack(:side => 'bottom', :fill => 'both')
+        }
         @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
 
@@ -75,15 +84,75 @@ module Drx
           display_variables(current_object)
           display_methods(current_object)
         }
+        @list.bind('ButtonRelease-3') {
+          back
+        }
+        @list.bind('Double-Button-1') {
+          descend_iclass
+        }
         @varsbox.bind('<ListboxSelect>') {
-          inspect_variable(current_object, @varsbox.get_selection)
+          print "\n== Variable #{@varsbox.get_selection}\n\n"
+          p selected_var
+        }
+        @varsbox.bind('Double-Button-1') {
+          see selected_var
+        }
+        @varsbox.bind('ButtonRelease-3') {
+          require 'pp'
+          print "\n== Variable #{@varsbox.get_selection}\n\n"
+          pp selected_var
+        }
+        @evalbox.bind('Key-Return') {
+          eval_code
+        }
+        @methodsbox.bind('Double-Button-1') {
+          locate_method(current_object, @methodsbox.get_selection)
         }
       end
 
-    #  def current_object=(obj)
-    #    @current_object = obj
-    #  end
-      
+      def open_up_editor(filename, lineno)
+        command = sprintf(ENV['DRX_EDITOR_COMMAND'] || EDITOR_COMMAND, lineno, filename)
+        puts "Execting: #{command}..."
+        if !fork
+          if !Kernel.system(command)
+            puts "Could not execure the command '#{command}'"
+          end
+          exit!
+        end
+      end
+
+      def locate_method(obj, method_name)
+        place = Drx.locate_method(obj, method_name)
+        if !place
+          puts "Method #{method_name} doesn't exist"
+        else
+          if place =~ /\A(\d+):(.*)/
+            open_up_editor($2, $1)
+          else
+            puts "Can't locate method, because: #{place}"
+          end
+        end
+      end
+
+      def back
+        if @stack.size > 1
+          @stack.pop
+          see @stack.pop
+        end
+      end
+
+      def selected_var
+        Drx.get_ivar(current_object, @varsbox.get_selection)
+      end
+
+      def eval_code
+        code = @evalbox.get.strip
+        see = !!code.sub!(/^see\s/, '')
+        result = current_object.instance_eval(code)
+        p result
+        see(result) if see
+      end
+
       def current_object
         @current_object
       end
@@ -92,15 +161,12 @@ module Drx
         @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
+          # Get rid of gazillions of Tk classes:
+          vars = vars.reject { |v| v =~ /Tk|Ttk/ }
           @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)) 
@@ -109,14 +175,32 @@ module Drx
         end
       end
       
-      def display_value(value)
+      def display_hierarchy(obj)
+        @list.delete('0', 'end')
         @objs = []
-        Drx.examine(value) do |line, obj|
+        Drx.examine(obj) do |line, o|
           @list.insert('end', line)
-          @objs << obj
+          @objs << o
         end
       end
       
+      def see(obj)
+        @current_object = obj
+        @stack << obj
+        display_hierarchy(obj)
+        display_variables(obj)
+        display_methods(obj)
+      end
+      
+      def descend_iclass
+        obj = if Drx.get_type(current_object) == Drx::T_ICLASS
+                Drx.get_klass(current_object)
+              else
+                current_object
+              end
+        see(obj)
+      end
+
       def run
         Tk.mainloop
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: drx
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Mooffie
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-03 00:00:00 +02:00
+date: 2009-02-04 00:00:00 +02:00
 default_executable: 
 dependencies: []