looksee 4.4.0 → 5.0.0

data/ext/mri/{2.3.0 → 3.2.0}/method.h

@@ -1,17 +1,20 @@
+#ifndef RUBY_METHOD_H
+#define RUBY_METHOD_H 1
 /**********************************************************************
 
   method.h -
 
-  $Author: ko1 $
+  $Author$
   created at: Wed Jul 15 20:02:33 2009
 
   Copyright (C) 2009 Koichi Sasada
 
 **********************************************************************/
-#ifndef RUBY_METHOD_H
-#define RUBY_METHOD_H 1
 
 #include "internal.h"
+#include "internal/imemo.h"
+#include "internal/compilers.h"
+#include "internal/static_assert.h"
 
 #ifndef END_OF_ENUMERATION
 # if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
@@ -33,15 +36,16 @@ typedef enum {
 } rb_method_visibility_t;
 
 typedef struct rb_scope_visi_struct {
-    rb_method_visibility_t method_visi : 3;
+    BITFIELD(rb_method_visibility_t, method_visi, 3);
     unsigned int module_func : 1;
 } rb_scope_visibility_t;
 
+/*! CREF (Class REFerence) */
 typedef struct rb_cref_struct {
     VALUE flags;
-    const VALUE refinements;
-    const VALUE klass;
-    struct rb_cref_struct * const next;
+    VALUE refinements;
+    VALUE klass_or_self;
+    struct rb_cref_struct * next;
     const rb_scope_visibility_t scope_visi;
 } rb_cref_t;
 
@@ -49,10 +53,10 @@ typedef struct rb_cref_struct {
 
 typedef struct rb_method_entry_struct {
     VALUE flags;
-    const VALUE defined_class;
+    VALUE defined_class;
     struct rb_method_definition_struct * const def;
     ID called_id;
-    const VALUE owner;
+    VALUE owner;
 } rb_method_entry_t;
 
 typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_entry_t */
@@ -65,8 +69,12 @@ typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_e
 
 #define METHOD_ENTRY_VISI(me)  (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))
 #define METHOD_ENTRY_BASIC(me) (int)                   (((me)->flags & (IMEMO_FL_USER2                 )) >> (IMEMO_FL_USHIFT+2))
-#define METHOD_ENTRY_COMPLEMENTED(me)     ((me)->flags & IMEMO_FL_USER3)
-#define METHOD_ENTRY_COMPLEMENTED_SET(me) ((me)->flags = (me)->flags | IMEMO_FL_USER3)
+#define METHOD_ENTRY_COMPLEMENTED(me)        ((me)->flags & IMEMO_FL_USER3)
+#define METHOD_ENTRY_COMPLEMENTED_SET(me)    ((me)->flags |= IMEMO_FL_USER3)
+#define METHOD_ENTRY_CACHED(me)              ((me)->flags & IMEMO_FL_USER4)
+#define METHOD_ENTRY_CACHED_SET(me)          ((me)->flags |= IMEMO_FL_USER4)
+#define METHOD_ENTRY_INVALIDATED(me)         ((me)->flags & IMEMO_FL_USER5)
+#define METHOD_ENTRY_INVALIDATED_SET(me)     ((me)->flags |= IMEMO_FL_USER5)
 
 static inline void
 METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)
@@ -87,32 +95,35 @@ METHOD_ENTRY_FLAGS_SET(rb_method_entry_t *me, rb_method_visibility_t visi, unsig
     VM_ASSERT(basic <= 1);
     me->flags =
       (me->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
-	((visi << (IMEMO_FL_USHIFT+0)) | (basic << (IMEMO_FL_USHIFT+2)));
+        ((visi << (IMEMO_FL_USHIFT+0)) | (basic << (IMEMO_FL_USHIFT+2)));
 }
 static inline void
 METHOD_ENTRY_FLAGS_COPY(rb_method_entry_t *dst, const rb_method_entry_t *src)
 {
     dst->flags =
       (dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
-	(src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2));
+        (src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2));
 }
 
 typedef enum {
-    VM_METHOD_TYPE_ISEQ,
-    VM_METHOD_TYPE_CFUNC,
-    VM_METHOD_TYPE_ATTRSET,
-    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_ISEQ,      /*!< Ruby method */
+    VM_METHOD_TYPE_CFUNC,     /*!< C method */
+    VM_METHOD_TYPE_ATTRSET,   /*!< attr_writer or attr_accessor */
+    VM_METHOD_TYPE_IVAR,      /*!< attr_reader or attr_accessor */
     VM_METHOD_TYPE_BMETHOD,
     VM_METHOD_TYPE_ZSUPER,
     VM_METHOD_TYPE_ALIAS,
     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,
+    VM_METHOD_TYPE_OPTIMIZED, /*!< Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING,   /*!< wrapper for method_missing(id) */
+    VM_METHOD_TYPE_REFINED,   /*!< refinement */
 
     END_OF_ENUMERATION(VM_METHOD_TYPE)
 } rb_method_type_t;
+#define VM_METHOD_TYPE_MINIMUM_BITS 4
+STATIC_ASSERT(VM_METHOD_TYPE_MINIMUM_BITS,
+              VM_METHOD_TYPE_REFINED <= (1<<VM_METHOD_TYPE_MINIMUM_BITS));
 
 #ifndef rb_iseq_t
 typedef struct rb_iseq_struct rb_iseq_t;
@@ -120,94 +131,123 @@ typedef struct rb_iseq_struct rb_iseq_t;
 #endif
 
 typedef struct rb_method_iseq_struct {
-    const rb_iseq_t * const iseqptr;              /* should be separated from iseqval */
-    rb_cref_t * const cref;                       /* should be marked */
+    const rb_iseq_t * iseqptr; /*!< iseq pointer, should be separated from iseqval */
+    rb_cref_t * cref;          /*!< class reference, should be marked */
 } rb_method_iseq_t; /* check rb_add_method_iseq() when modify the fields */
 
 typedef struct rb_method_cfunc_struct {
     VALUE (*func)(ANYARGS);
-    VALUE (*invoker)(VALUE (*func)(ANYARGS), VALUE recv, int argc, const VALUE *argv);
+    VALUE (*invoker)(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS));
     int argc;
 } rb_method_cfunc_t;
 
 typedef struct rb_method_attr_struct {
     ID id;
-    const VALUE location; /* should be marked */
+    VALUE location; /* should be marked */
 } rb_method_attr_t;
 
 typedef struct rb_method_alias_struct {
-    const struct rb_method_entry_struct * const original_me; /* original_me->klass is original owner */
+    struct rb_method_entry_struct * original_me; /* original_me->klass is original owner */
 } rb_method_alias_t;
 
 typedef struct rb_method_refined_struct {
-    const struct rb_method_entry_struct * const orig_me;
-    const VALUE owner;
+    struct rb_method_entry_struct * orig_me;
+    VALUE owner;
 } rb_method_refined_t;
 
-typedef struct rb_method_definition_struct {
-    rb_method_type_t type :  8; /* method type */
-    int alias_count       : 28;
-    int complemented_count: 28;
+typedef struct rb_method_bmethod_struct {
+    VALUE proc; /* should be marked */
+    struct rb_hook_list_struct *hooks;
+    VALUE defined_ractor;
+} rb_method_bmethod_t;
+
+enum method_optimized_type {
+    OPTIMIZED_METHOD_TYPE_SEND,
+    OPTIMIZED_METHOD_TYPE_CALL,
+    OPTIMIZED_METHOD_TYPE_BLOCK_CALL,
+    OPTIMIZED_METHOD_TYPE_STRUCT_AREF,
+    OPTIMIZED_METHOD_TYPE_STRUCT_ASET,
+    OPTIMIZED_METHOD_TYPE__MAX
+};
+
+typedef struct rb_method_optimized {
+    enum method_optimized_type type;
+    unsigned int index;
+} rb_method_optimized_t;
+
+struct rb_method_definition_struct {
+    BITFIELD(rb_method_type_t, type, VM_METHOD_TYPE_MINIMUM_BITS);
+    unsigned int iseq_overload: 1;
+    int alias_count : 27;
+    int complemented_count : 28;
+    unsigned int no_redef_warning: 1;
 
     union {
-	rb_method_iseq_t iseq;
-	rb_method_cfunc_t cfunc;
-	rb_method_attr_t attr;
-	rb_method_alias_t alias;
-	rb_method_refined_t refined;
-
-	const VALUE proc;                 /* should be marked */
-	enum method_optimized_type {
-	    OPTIMIZED_METHOD_TYPE_SEND,
-	    OPTIMIZED_METHOD_TYPE_CALL,
-
-	    OPTIMIZED_METHOD_TYPE__MAX
-	} optimize_type;
+        rb_method_iseq_t iseq;
+        rb_method_cfunc_t cfunc;
+        rb_method_attr_t attr;
+        rb_method_alias_t alias;
+        rb_method_refined_t refined;
+        rb_method_bmethod_t bmethod;
+        rb_method_optimized_t optimized;
     } body;
 
     ID original_id;
-} rb_method_definition_t;
+    uintptr_t method_serial;
+};
+
+struct rb_id_table;
+
+typedef struct rb_method_definition_struct rb_method_definition_t;
+STATIC_ASSERT(sizeof_method_def, offsetof(rb_method_definition_t, body)==8);
 
 #define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
 #define UNDEFINED_REFINED_METHOD_P(def) \
     ((def)->type == VM_METHOD_TYPE_REFINED && \
      UNDEFINED_METHOD_ENTRY_P((def)->body.refined.orig_me))
 
+void rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi);
 void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_visibility_t visi);
 void rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_method_visibility_t visi);
+void rb_add_method_optimized(VALUE klass, ID mid, enum method_optimized_type, unsigned int index, rb_method_visibility_t visi);
 void rb_add_refined_method_entry(VALUE refined_class, ID mid);
 
-rb_method_entry_t *rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi);
 rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex);
 rb_method_entry_t *rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, const rb_method_definition_t *def);
 
 const rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
 
 const rb_method_entry_t *rb_method_entry(VALUE klass, ID id);
-const rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id);
-const rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id);
+const rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class);
+const rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class);
 const rb_method_entry_t *rb_resolve_refined_method(VALUE refinements, const rb_method_entry_t *me);
+RUBY_SYMBOL_EXPORT_BEGIN
+const rb_method_entry_t *rb_resolve_me_location(const rb_method_entry_t *, VALUE[5]);
+RUBY_SYMBOL_EXPORT_END
 
 const rb_callable_method_entry_t *rb_callable_method_entry(VALUE klass, ID id);
-const rb_callable_method_entry_t *rb_callable_method_entry_with_refinements(VALUE klass, ID id);
-const rb_callable_method_entry_t *rb_callable_method_entry_without_refinements(VALUE klass, ID id);
-const rb_callable_method_entry_t *rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me);
+const rb_callable_method_entry_t *rb_callable_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class);
+const rb_callable_method_entry_t *rb_callable_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class);
 
 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(const 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_free_method_entry(const rb_method_entry_t *me);
-void rb_sweep_method_entry(void *vm);
 
 const rb_method_entry_t *rb_method_entry_clone(const rb_method_entry_t *me);
-const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, VALUE defined_class);
+const rb_callable_method_entry_t *rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class);
 void rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src);
 
+void rb_method_table_insert(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me);
+
 void rb_scope_visibility_set(rb_method_visibility_t);
 
+VALUE rb_unnamed_parameters(int arity);
+
+void rb_clear_method_cache(VALUE klass_or_module, ID mid);
+void rb_clear_method_cache_all(void);
+
 #endif /* RUBY_METHOD_H */

data/ext/mri/mri.c

@@ -1,56 +1,24 @@
 #include "ruby.h"
 
-#if RUBY_VERSION >= 230
-#  define VM_ASSERT(expr) ((void)0)
-#endif
-
-#include "method.h"
-#include "internal.h"
-
-#ifndef Looksee_method_table_foreach
-#  define Looksee_method_table_foreach st_foreach
-#  define Looksee_method_table_lookup st_lookup
-#endif
-
-#if RUBY_VERSION < 230
-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;
-}
-#endif
-
+#if RUBY_VERSION < 320
 /*
  * Return the list of undefined instance methods (as Symbols) of the
  * given internal class.
  */
 VALUE Looksee_internal_undefined_instance_methods(VALUE self, VALUE klass) {
-#if RUBY_VERSION >= 230
   static int warned = 0;
   if (!warned) {
-    rb_warn("Looksee cannot display undef-ed methods on MRI 2.3 or later");
+    rb_warn("Looksee cannot display undef-ed methods on MRI < 3.2");
     warned = 1;
   }
   return rb_ary_new();
-#else
-  VALUE names = rb_ary_new();
-  if (RCLASS_ORIGIN(klass) != klass)
-    klass = RCLASS_ORIGIN(klass);
-  Looksee_method_table_foreach(RCLASS_M_TBL(klass), add_method_if_undefined, (st_data_t)&names);
-  return names;
-#endif
 }
+#endif
 
 VALUE Looksee_singleton_instance(VALUE self, VALUE klass) {
   if (!SPECIAL_CONST_P(klass) && BUILTIN_TYPE(klass) == T_CLASS && FL_TEST(klass, FL_SINGLETON)) {
-    VALUE object;
-    if (!Looksee_method_table_lookup(RCLASS_IV_TBL(klass), rb_intern("__attached__"), (st_data_t *)&object))
+    VALUE object = rb_ivar_get(klass, rb_intern("__attached__"));
+    if (object == Qnil)
       rb_raise(rb_eRuntimeError, "[looksee bug] can't find singleton object");
     return object;
   } else {
@@ -63,6 +31,8 @@ void Init_mri(void) {
   VALUE mAdapter = rb_const_get(mLooksee, rb_intern("Adapter"));
   VALUE mBase = rb_const_get(mAdapter, rb_intern("Base"));
   VALUE mMRI = rb_define_class_under(mAdapter, "MRI", mBase);
+#if RUBY_VERSION < 320
   rb_define_method(mMRI, "internal_undefined_instance_methods", Looksee_internal_undefined_instance_methods, 1);
+#endif
   rb_define_method(mMRI, "singleton_instance", Looksee_singleton_instance, 1);
 }

data/lib/looksee/adapter/base.rb

@@ -9,11 +9,11 @@ module Looksee
         start =
           begin
             singleton_class = (class << object; self; end)
-            singleton_class unless has_no_methods?(singleton_class) && !(Class === object)
+            singleton_class unless has_no_methods?(singleton_class) && includes_no_modules?(singleton_class) && !(Class === object)
           rescue TypeError  # immediate object
           end
         start ||= Looksee.safe_call(Object, :class, object)
-        start.ancestors
+        Looksee.safe_call(Module, :ancestors, start)
       end
 
       #
@@ -48,6 +48,14 @@ module Looksee
         end
       end
 
+      def undefined_instance_methods(mod)
+        if Module.method_defined?(:undefined_instance_methods)
+          mod.undefined_instance_methods
+        else
+          internal_undefined_instance_methods(mod)
+        end
+      end
+
       def internal_undefined_instance_methods(mod)
         raise NotImplementedError, "abstract"
       end
@@ -55,7 +63,13 @@ module Looksee
       def has_no_methods?(mod)
         [:public, :protected, :private].all? do |visibility|
           Looksee.safe_call(Module, "#{visibility}_instance_methods", mod, false).empty?
-        end && internal_undefined_instance_methods(mod).empty?
+        end && undefined_instance_methods(mod).empty?
+      end
+
+      def includes_no_modules?(klass)
+        ancestors = Looksee.safe_call(Module, :ancestors, klass)
+        ancestors.size == 1 ||
+          klass.included_modules == klass.ancestors[1].included_modules
       end
 
       def singleton_instance(singleton_class)

data/lib/looksee/adapter.rb

@@ -3,6 +3,5 @@ module Looksee
     autoload :Base, 'looksee/adapter/base'
     autoload :MRI, "looksee/mri.#{Looksee::Config::CONFIG['DLEXT']}"
     autoload :JRuby, 'looksee/JRuby.jar'
-    autoload :Rubinius, "looksee/adapter/rubinius"
   end
 end

data/lib/looksee/clean.rb

@@ -18,7 +18,7 @@ module Looksee
 
   class << self
     #
-    # The default options passed to #ls.
+    # The default options passed to #look.
     #
     # Default: <tt>[:public, :protected, :private, :undefined,
     # :overridden]</tt>
@@ -165,8 +165,6 @@ module Looksee
   case ruby_engine
   when 'jruby'
     self.adapter = Adapter::JRuby.new
-  when 'rbx'
-    self.adapter = Adapter::Rubinius.new
   else
     self.adapter = Adapter::MRI.new
   end

data/lib/looksee/core_ext.rb

@@ -3,28 +3,40 @@ module Looksee
     #
     # Shortcut for Looksee[self, *args].
     #
-    def ls(*args)
+    def look(*args)
       Looksee[self, *args]
     end
 
     def self.rename(name)  # :nodoc:
-      name = name[:ls] if name.is_a?(Hash)
-      alias_method name, :ls
-      remove_method :ls
+      if name.is_a?(Hash)
+        warning = "You have renamed Looksee's method with Looksee.rename(#{name.inspect}).\n\n" +
+                  "Looksee now uses #look instead of #ls."
+        if name[:ls].to_s == 'look'
+          warn warning << " You can remove this customization."
+        elsif name[:ls]
+          warn warning << " Please rename with Looksee.rename(#{name[:ls].inspect}), or remove this customization."
+        end
+      elsif name.to_s == 'look'
+        warn warning << " You can remove this customization."
+      end
+
+      name = name[:look] || name[:ls] if name.is_a?(Hash)
+      alias_method name, :look
+      remove_method :look
     end
   end
 
   #
-  # Rename the #ls method, added to every object. Example:
+  # Rename the #look method, added to every object. Example:
   #
-  #     rename :_ls
+  #     rename :_look
   #
-  # This renames Looksee's #ls method to #_ls.
+  # This renames Looksee's #look method to #_look.
   #
   # For backward compatibility, the old-style invocation is also
-  # supported. Please note this is deprecated.
+  # supported. This is deprecated, and will shortly be removed.
   #
-  #     rename :ls => :_ls
+  #     rename :look => :_look
   #
   def self.rename(name)
     ObjectMixin.rename(name)

data/lib/looksee/help.rb

@@ -4,7 +4,7 @@ module Looksee
       <<-EOS.gsub(/^ *\|/, '')
         |== Looksee Quick Reference
         |
-        |  \e[1mobject.ls(*specifiers)\e[0m  or  \e[1mLooksee[object, *specifiers]\e[0m
+        |  \e[1mobject.look(*specifiers)\e[0m  or  \e[1mLooksee[object, *specifiers]\e[0m
         |
         |    Print the methods of \`object\'.
         |
@@ -41,7 +41,7 @@ module Looksee
         |          ...
         |        }
         |
-        |  \e[1mobject.ls.edit(method)\e[0m
+        |  \e[1mobject.look.edit(method)\e[0m
         |
         |    Jump to the source of the given method. Set your editor
         |    with Looksee.editor or the LOOKSEE_EDITOR environment

data/lib/looksee/inspector.rb

@@ -20,6 +20,17 @@ module Looksee
       end.join("\n")
     end
 
+    def pretty_print(pp)
+      # In the default IRB inspect mode (pp), IRB assumes that an inspect string
+      # that doesn't look like a bunch of known patterns is a code blob, and
+      # formats accordingly. That messes up our color escapes.
+      if Object.const_defined?(:IRB) && IRB.const_defined?(:ColorPrinter) && pp.is_a?(IRB::ColorPrinter)
+        PP.instance_method(:text).bind(pp).call(inspect)
+      else
+        pp.text(inspect)
+      end
+    end
+
     #
     # Open an editor at the named method's definition.
     #

data/lib/looksee/lookup_path.rb

@@ -89,7 +89,7 @@ module Looksee
             methods[method.to_s] = visibility
           end
         end
-        Looksee.adapter.send("internal_undefined_instance_methods", @module).each do |method|
+        Looksee.adapter.undefined_instance_methods(@module).each do |method|
           methods[method.to_s] = :undefined
         end
         methods

data/lib/looksee/version.rb

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

data/spec/looksee/adapter_spec.rb

@@ -67,6 +67,14 @@ describe "Looksee.adapter" do
         ['[C]', '[Object]', '[BasicObject]', 'Class', 'Module', 'Object', 'Kernel', 'BasicObject']
     end
 
+    it "should contain entries for modules included in the singleton class" do
+      temporary_module :M
+      c = Object.new
+      c.extend(M)
+      filtered_lookup_modules(c).should ==
+        ['[Object instance]', 'M', 'Object', 'Kernel', 'BasicObject']
+    end
+
     it "should work for immediate objects" do
       if RUBY_VERSION >= "2.4.0"
         filtered_lookup_modules(1).first.should == 'Integer'
@@ -76,61 +84,59 @@ describe "Looksee.adapter" do
     end
   end
 
-  describe "internal instance methods:" do
+  describe ".undefined_instance_methods" do
     def self.target_method(name)
       define_method(:target_method){name}
     end
 
-    describe ".internal_undefined_instance_methods" do
-      if Looksee.ruby_engine == 'ruby' && RUBY_VERSION >= '2.3'
-        it "just returns an empty array" do
-          temporary_class :C
-          add_methods C, undefined: [:f]
-          @adapter.internal_undefined_instance_methods(C).should == []
-        end
-      else
-        it "should return the list of undefined instance methods directly on a class" do
-          temporary_class :C
-          add_methods(C, undefined: [:f])
-          @adapter.internal_undefined_instance_methods(C).should == [:f]
-        end
+    if Looksee.ruby_engine == 'ruby' && RUBY_VERSION >= '2.3' && RUBY_VERSION < '3.2'
+      it "just returns an empty array" do
+        temporary_class :C
+        add_methods C, undefined: [:f]
+        @adapter.undefined_instance_methods(C).should == []
+      end
+    else
+      it "should return the list of undefined instance methods directly on a class" do
+        temporary_class :C
+        add_methods(C, undefined: [:f])
+        @adapter.undefined_instance_methods(C).should == [:f]
+      end
 
-        it "should return the list of undefined instance methods directly on a module" do
-          temporary_module :M
-          add_methods(M, undefined: [:f])
-          @adapter.internal_undefined_instance_methods(M).should == [:f]
-        end
+      it "should return the list of undefined instance methods directly on a module" do
+        temporary_module :M
+        add_methods(M, undefined: [:f])
+        @adapter.undefined_instance_methods(M).should == [:f]
+      end
 
-        it "should return the list of undefined instance methods directly on a singleton class" do
-          temporary_class :C
-          c = C.new
-          add_methods(c.singleton_class, undefined: [:f])
-          @adapter.internal_undefined_instance_methods(c.singleton_class).should == [:f]
-        end
+      it "should return the list of undefined instance methods directly on a singleton class" do
+        temporary_class :C
+        c = C.new
+        add_methods(c.singleton_class, undefined: [:f])
+        @adapter.undefined_instance_methods(c.singleton_class).should == [:f]
+      end
 
-        it "should return the list of undefined instance methods directly on a class' singleton class" do
-          temporary_class :C
-          add_methods(C.singleton_class, undefined: [:f])
-          @adapter.internal_undefined_instance_methods(C.singleton_class).should == [:f]
-        end
+      it "should return the list of undefined instance methods directly on a class' singleton class" do
+        temporary_class :C
+        add_methods(C.singleton_class, undefined: [:f])
+        @adapter.undefined_instance_methods(C.singleton_class).should == [:f]
+      end
 
-        it "should not return defined methods" do
-          temporary_class :C
-          C.send(:define_method, :f){}
-          @adapter.internal_undefined_instance_methods(C).should == []
-        end
+      it "should not return defined methods" do
+        temporary_class :C
+        C.send(:define_method, :f){}
+        @adapter.undefined_instance_methods(C).should == []
+      end
 
-        it "should not return removed methods" do
-          temporary_class :C
-          C.send(:define_method, :f){}
-          C.send(:remove_method, :f)
-          @adapter.internal_undefined_instance_methods(C).should == []
-        end
+      it "should not return removed methods" do
+        temporary_class :C
+        C.send(:define_method, :f){}
+        C.send(:remove_method, :f)
+        @adapter.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
+      it "should handle the MRI allocator being undefined (e.g. Struct)" do
+        struct_singleton_class = (class << Struct; self; end)
+        @adapter.undefined_instance_methods(struct_singleton_class).should == []
       end
     end
   end

data/spec/looksee/core_ext_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Looksee::ObjectMixin do
-  describe "#ls" do
+  describe "#look" do
     before do
       @object = Object.new
       Looksee.stub(:default_specifiers).and_return([])
     end
 
     it "should return an Inspector for the object's lookup path using the given arguments" do
-      result = @object.ls(:private)
+      result = @object.look(:private)
       result.should be_a(Looksee::Inspector)
       result.lookup_path.object.should.equal?(@object)
       result.visibilities.should == Set[:private]