looksee 1.0.3-universal-java-1.6 → 2.0.0-universal-java-1.6

data/ext/mri/2.1.0/method.h

@@ -0,0 +1,142 @@
+/**********************************************************************
+
+  method.h -
+
+  $Author: tmm1 $
+  created at: Wed Jul 15 20:02:33 2009
+
+  Copyright (C) 2009 Koichi Sasada
+
+**********************************************************************/
+#ifndef METHOD_H
+#define METHOD_H
+
+#include "internal.h"
+
+#ifndef END_OF_ENUMERATION
+# if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
+#   define END_OF_ENUMERATION(key)
+# else
+#   define END_OF_ENUMERATION(key) END_OF_##key##_PLACEHOLDER = 0
+# endif
+#endif
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80,
+
+    NOEX_BIT_WIDTH = 8,
+    NOEX_SAFE_SHIFT_OFFSET = ((NOEX_BIT_WIDTH+3)/4)*4 /* round up to nibble */
+} rb_method_flag_t;
+
+#define NOEX_SAFE(n) ((int)((n) >> NOEX_SAFE_SHIFT_OFFSET) & 0x0F)
+#define NOEX_WITH(n, s) (((s) << NOEX_SAFE_SHIFT_OFFSET) | (n) | (ruby_running ? 0 : NOEX_BASIC))
+#define NOEX_WITH_SAFE(n) NOEX_WITH((n), rb_safe_level())
+
+/* method data type */
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING,   /* wrapper for method_missing(id) */
+    VM_METHOD_TYPE_REFINED,
+
+    END_OF_ENUMERATION(VM_METHOD_TYPE)
+} rb_method_type_t;
+
+struct rb_call_info_struct;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    VALUE (*invoker)(VALUE (*func)(ANYARGS), VALUE recv, int argc, const VALUE *argv);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    const VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t * const iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	const VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL,
+
+	    OPTIMIZED_METHOD_TYPE__MAX
+	} optimize_type;
+	struct rb_method_entry_struct *orig_me;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+struct unlinked_method_entry_list_entry {
+    struct unlinked_method_entry_list_entry *next;
+    rb_method_entry_t *me;
+};
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+
+void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_flag_t noex);
+rb_method_entry_t *rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex);
+rb_method_entry_t *rb_method_entry(VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
+void rb_add_refined_method_entry(VALUE refined_class, ID mid);
+rb_method_entry_t *rb_resolve_refined_method(VALUE refinements,
+					     const rb_method_entry_t *me,
+					     VALUE *defined_class_ptr);
+rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id,
+						    VALUE *defined_class_ptr);
+rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id,
+						       VALUE *defined_class_ptr);
+
+rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_flag_t noex);
+
+int rb_method_entry_arity(const rb_method_entry_t *me);
+int rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2);
+st_index_t rb_hash_method_entry(st_index_t hash, const rb_method_entry_t *me);
+
+VALUE rb_method_entry_location(rb_method_entry_t *me);
+VALUE rb_mod_method_location(VALUE mod, ID id);
+VALUE rb_obj_method_location(VALUE obj, ID id);
+
+void rb_mark_method_entry(const rb_method_entry_t *me);
+void rb_free_method_entry(rb_method_entry_t *me);
+void rb_sweep_method_entry(void *vm);
+void rb_free_m_tbl(st_table *tbl);
+void rb_free_m_tbl_wrapper(struct method_table_wrapper *wrapper);
+
+#endif /* METHOD_H */

data/ext/mri/mri.c

@@ -1,10 +1,19 @@
 #include "ruby.h"
 
-#if RUBY_VERSION >= 193
+#if RUBY_VERSION >= 200
+#  include "method.h"
 #  include "internal.h"
+#elif RUBY_VERSION >= 193
+#  include "ruby/st.h"
+#  ifdef SA_EMPTY
+#    include "internal_falcon.h"
+#    define Looksee_method_table_foreach sa_foreach
+#    define Looksee_method_table_lookup sa_lookup
+#  else
+#    include "internal.h"
+#  endif
 #  include "vm_core.h"
 #  include "method.h"
-#  include "ruby/st.h"
 #elif RUBY_VERSION >= 192
 #  include "vm_core.h"
 #  include "method.h"
@@ -17,6 +26,11 @@
 #  include "st.h"
 #endif
 
+#ifndef Looksee_method_table_foreach
+#  define Looksee_method_table_foreach st_foreach
+#  define Looksee_method_table_lookup st_lookup
+#endif
+
 #if RUBY_VERSION < 187
 #  define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
 #  define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
@@ -77,8 +91,10 @@ typedef struct add_method_if_matching_arg {
 } add_method_if_matching_arg_t;
 
 static int add_method_if_matching(ID method_name, rb_method_entry_t *me, add_method_if_matching_arg_t *arg) {
+#  ifdef ID_ALLOCATOR
   if (method_name == ID_ALLOCATOR)
     return ST_CONTINUE;
+#  endif
 
   if (UNDEFINED_METHOD_ENTRY_P(me))
     return ST_CONTINUE;
@@ -90,6 +106,12 @@ static int add_method_if_matching(ID method_name, rb_method_entry_t *me, add_met
 }
 
 static int add_method_if_undefined(ID method_name, rb_method_entry_t *me, VALUE *names) {
+#  ifdef ID_ALLOCATOR
+  /* The allocator can be undefined with rb_undef_alloc_func, e.g. Struct. */
+  if (method_name == ID_ALLOCATOR)
+    return ST_CONTINUE;
+#  endif
+
   if (UNDEFINED_METHOD_ENTRY_P(me))
     rb_ary_push(*names, ID2SYM(method_name));
   return ST_CONTINUE;
@@ -111,9 +133,11 @@ typedef struct add_method_if_matching_arg {
 } add_method_if_matching_arg_t;
 
 static int add_method_if_matching(ID method_name, NODE *body, add_method_if_matching_arg_t *arg) {
+#  ifdef ID_ALLOCATOR
   /* This entry is for the internal allocator function. */
   if (method_name == ID_ALLOCATOR)
     return ST_CONTINUE;
+#  endif
 
   /* Module#undef_method:
    *   * sets body->nd_body to NULL in ruby <= 1.8
@@ -128,6 +152,12 @@ static int add_method_if_matching(ID method_name, NODE *body, add_method_if_matc
 }
 
 static int add_method_if_undefined(ID method_name, NODE *body, VALUE *names) {
+#  ifdef ID_ALLOCATOR
+  /* The allocator can be undefined with rb_undef_alloc_func, e.g. Struct. */
+  if (method_name == ID_ALLOCATOR)
+    return ST_CONTINUE;
+#  endif
+
   if (!body || !body->nd_body)
     rb_ary_push(*names, ID2SYM(method_name));
   return ST_CONTINUE;
@@ -139,7 +169,8 @@ static VALUE internal_instance_methods(VALUE klass, VISIBILITY_TYPE visibility)
   add_method_if_matching_arg_t arg;
   arg.names = rb_ary_new();
   arg.visibility = visibility;
-  st_foreach(RCLASS_M_TBL(klass), add_method_if_matching, (st_data_t)&arg);
+
+  Looksee_method_table_foreach(RCLASS_M_TBL(klass), add_method_if_matching, (st_data_t)&arg);
   return arg.names;
 }
 
@@ -173,7 +204,7 @@ VALUE Looksee_internal_private_instance_methods(VALUE self, VALUE klass) {
  */
 VALUE Looksee_internal_undefined_instance_methods(VALUE self, VALUE klass) {
   VALUE names = rb_ary_new();
-  st_foreach(RCLASS_M_TBL(klass), add_method_if_undefined, (st_data_t)&names);
+  Looksee_method_table_foreach(RCLASS_M_TBL(klass), add_method_if_undefined, (st_data_t)&names);
   return names;
 }
 
@@ -184,7 +215,7 @@ VALUE Looksee_singleton_class_p(VALUE self, VALUE object) {
 VALUE Looksee_singleton_instance(VALUE self, VALUE singleton_class) {
   if (BUILTIN_TYPE(singleton_class) == T_CLASS && FL_TEST(singleton_class, FL_SINGLETON)) {
     VALUE object;
-    if (!st_lookup(RCLASS_IV_TBL(singleton_class), rb_intern("__attached__"), (st_data_t *)&object))
+    if (!Looksee_method_table_lookup(RCLASS_IV_TBL(singleton_class), rb_intern("__attached__"), (st_data_t *)&object))
       rb_raise(rb_eRuntimeError, "[looksee bug] can't find singleton object");
     return object;
   } else {

data/lib/looksee/adapter/rubinius.rb

@@ -30,26 +30,31 @@ module Looksee
 
       def internal_undefined_instance_methods(mod)
         names = []
-        mod.method_table.each_entry do |entry|
-          names << entry.name if entry.visibility.equal?(:undef)
+        mod.method_table.entries.each do |(name, method, visibility)|
+          names << name if visibility.equal?(:undef)
         end
         names
       end
 
       def singleton_class?(object)
-        object.is_a?(Class) && object.__metaclass_object__
+        object.is_a?(Class) && !!::Rubinius::Type.singleton_class_object(object)
       end
 
       def singleton_instance(singleton_class)
         singleton_class?(singleton_class) or
           raise TypeError, "expected singleton class, got #{singleton_class.class}"
-        singleton_class.__metaclass_object__
+        ::Rubinius::Type.singleton_class_object(singleton_class)
       end
 
       def module_name(mod)
         mod.is_a?(Module) or
           raise TypeError, "expected module, got #{mod.class}"
-        mod.__name__
+
+        if ::Rubinius::Type.respond_to?(:module_name)
+          ::Rubinius::Type.module_name(mod) || ''
+        else
+          mod.__name__
+        end
       end
 
       def source_location(method)

data/lib/looksee/clean.rb

@@ -4,6 +4,10 @@ require 'set'
 module Looksee
   Config = Object.const_defined?(:RbConfig) ? ::RbConfig : ::Config
 
+  NoMethodError = Class.new(RuntimeError)
+  NoSourceLocationError = Class.new(RuntimeError)
+  NoSourceFileError = Class.new(RuntimeError)
+
   autoload :VERSION, 'looksee/version'
   autoload :Adapter, 'looksee/adapter'
   autoload :Columnizer, 'looksee/columnizer'

data/lib/looksee/core_ext.rb

@@ -42,38 +42,31 @@ module Looksee
       Inspector.new(lookup_path, options)
     end
 
-    #
-    # Open an editor at the named method's definition.
-    #
-    # Uses Looksee.editor to determine the editor command to run.
-    #
-    # Only works for methods for which file and line numbers are
-    # accessible.
-    #
-    def edit(name)
-      Editor.new(Looksee.editor).edit(self, name)
-    end
-
-    def self.rename(renamings)  # :nodoc:
-      renamings.each do |old_name, new_name|
-        alias_method new_name, old_name
-        remove_method old_name
-      end
+    def self.rename(name)  # :nodoc:
+      name = name[:ls] if name.is_a?(Hash)
+      alias_method name, :ls
+      remove_method :ls
     end
   end
 
   #
-  # Rename the methods added to every object. Example:
+  # Rename the #ls method, added to every object. Example:
+  #
+  #     rename :_ls
+  #
+  # This renames Looksee's #ls method to #_ls.
   #
-  #     rename :ls => :_ls, :edit => :_edit
+  # For backward compatibility, the old-style invocation is also
+  # supported. Please note this is deprecated.
   #
-  def self.rename(renamings)
-    ObjectMixin.rename(renamings)
+  #     rename :ls => :_ls
+  #
+  def self.rename(name)
+    ObjectMixin.rename(name)
   end
 
-  (ENV['LOOKSEE_METHODS'] || '').scan(/([\w_]+)=([\w_]+)/) do
-    rename $1.to_sym => $2.to_sym
-  end
+  name = ENV['LOOKSEE_METHOD'] and
+    rename name
 
   Object.send :include, ObjectMixin
 end

data/lib/looksee/editor.rb

@@ -14,9 +14,15 @@ module Looksee
     #
     def edit(object, method_name)
       method = LookupPath.new(object).find(method_name.to_s) or
-        return
+        raise NoMethodError, "no method `#{method_name}' in lookup path of #{object.class} instance"
       file, line = Looksee.adapter.source_location(method)
-      run(file, line) unless line.nil?
+      if !file
+        raise NoSourceLocationError, "no source location for #{method.owner}##{method.name}"
+      elsif !File.exist?(file)
+        raise NoSourceFileError, "cannot find source file: #{file}"
+      else
+        run(file, line)
+      end
     end
 
     #

data/lib/looksee/help.rb

@@ -40,7 +40,7 @@ module Looksee
         |          ...
         |        }
         |
-        |  object.edit(method)
+        |  object.ls.edit(method)
         |
         |    Jump to the source of the given method. Set your editor
         |    with Looksee.editor or the LOOKSEE_EDITOR environment

data/lib/looksee/inspector.rb

@@ -11,12 +11,27 @@ module Looksee
     attr_reader :visibilities
     attr_reader :filters
 
+    #
+    # Print the method lookup path of self. See the README for details.
+    #
     def inspect
       lookup_path.entries.reverse.map do |entry|
         inspect_entry(entry)
       end.join("\n")
     end
 
+    #
+    # Open an editor at the named method's definition.
+    #
+    # Uses Looksee.editor to determine the editor command to run.
+    #
+    # Only works for methods for which file and line numbers are
+    # accessible.
+    #
+    def edit(name)
+      Editor.new(Looksee.editor).edit(lookup_path.object, name)
+    end
+
     private
 
     def inspect_entry(entry)

data/lib/looksee/version.rb

@@ -1,5 +1,5 @@
 module Looksee
-  VERSION = [1, 0, 3]
+  VERSION = [2, 0, 0]
 
   class << VERSION
     include Comparable

data/spec/adapter_spec.rb

@@ -95,33 +95,33 @@ describe "Looksee.adapter" do
     def self.it_should_list_methods_with_visibility(visibility)
       it "should return the list of #{visibility} instance methods defined directly on a class" do
         temporary_class :C
-        replace_methods C, visibility => [:one, :two]
+        add_methods C, visibility => [:one, :two]
         @adapter.send(target_method, C).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a module" do
         temporary_module :M
-        replace_methods M, visibility => [:one, :two]
+        add_methods M, visibility => [:one, :two]
         @adapter.send(target_method, M).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a singleton class" do
         temporary_class :C
         c = C.new
-        replace_methods c.singleton_class, visibility => [:one, :two]
+        add_methods c.singleton_class, visibility => [:one, :two]
         @adapter.send(target_method, c.singleton_class).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a class' singleton class" do
         temporary_class :C
-        replace_methods C.singleton_class, visibility => [:one, :two], :class_singleton => true
+        add_methods C.singleton_class, visibility => [:one, :two], :class_singleton => true
         @adapter.send(target_method, C.singleton_class).to_set.should == Set[:one, :two]
       end
 
       # Worth checking as ruby keeps undef'd methods in method tables.
       it "should not return undefined methods" do
         temporary_class :C
-        replace_methods C, visibility => [:removed]
+        add_methods C, visibility => [:removed]
         C.send(:undef_method, :removed)
         @adapter.send(target_method, C).to_set.should == Set[]
       end
@@ -130,7 +130,7 @@ describe "Looksee.adapter" do
     def self.it_should_not_list_methods_with_visibility(visibility1, visibility2)
       it "should not return any #{visibility1} or #{visibility2} instance methods" do
         temporary_class :C
-        replace_methods C, {visibility1 => [:a], visibility2 => [:b]}
+        add_methods C, {visibility1 => [:a], visibility2 => [:b]}
         @adapter.send(target_method, C).to_set.should == Set[]
       end
     end
@@ -195,6 +195,11 @@ describe "Looksee.adapter" do
         C.send(:remove_method, :f)
         @adapter.internal_undefined_instance_methods(C).should == []
       end
+
+      it "should handle the MRI allocator being undefined (e.g. Struct)" do
+        struct_singleton_class = (class << Struct; self; end)
+        @adapter.internal_undefined_instance_methods(struct_singleton_class).should == []
+      end
     end
   end
 
@@ -431,7 +436,8 @@ describe "Looksee.adapter" do
   describe "#source_location" do
     def load_source(source)
       @tmp = "#{ROOT}/spec/tmp"
-      @source_path = "#@tmp/c.rb"
+      # rbx 1.2.3 caches the file content by file name - ensure file names are different.
+      @source_path = "#@tmp/c#{__id__}.rb"
       FileUtils.mkdir_p @tmp
       open(@source_path, 'w') { |f| f.print source }
       load @source_path