looksee 3.1.1 → 4.0.0

data/ext/rbx/rbx.c

@@ -1,13 +1,4 @@
 #include "ruby.h"
 
-VALUE Looksee_internal_class(VALUE self, VALUE object) {
-  return CLASS_OF(object);
-}
-
 void Init_rbx(void) {
-  VALUE mLooksee = rb_const_get(rb_cObject, rb_intern("Looksee"));
-  VALUE mAdapter = rb_const_get(mLooksee, rb_intern("Adapter"));
-  VALUE mBase = rb_const_get(mAdapter, rb_intern("Base"));
-  VALUE mRubinius = rb_define_class_under(mAdapter, "Rubinius", mBase);
-  rb_define_method(mRubinius, "internal_class", Looksee_internal_class, 1);
 }

data/lib/looksee/adapter/base.rb

@@ -6,13 +6,14 @@ module Looksee
       # object's method lookup path.
       #
       def lookup_modules(object)
-        modules = []
-        klass = internal_class(object)
-        while klass
-          modules << klass
-          klass = internal_superclass(klass)
-        end
-        modules
+        start =
+          begin
+            singleton_class = (class << object; self; end)
+            singleton_class unless has_no_methods?(singleton_class) && !(Class === object)
+          rescue TypeError  # immediate object
+          end
+        start ||= Looksee.safe_call(Object, :class, object)
+        start.ancestors
       end
 
       #
@@ -21,17 +22,19 @@ module Looksee
       # This is used for the module labels in the Inspector output.
       #
       def describe_module(mod)
+        Module === mod or
+          raise TypeError, "expected Module, got: #{mod.inspect}"
         num_brackets = 0
         object = mod
-        while singleton_class?(object)
+        while (instance = singleton_instance(object))
           num_brackets += 1
-          object = singleton_instance(object)
+          object = instance
         end
 
-        if included_class?(mod) || object.is_a?(Module)
+        if object.is_a?(Module)
           description = module_name(object)
           if description.empty?
-            is_class = real_module(object).is_a?(Class)
+            is_class = Class === object
             description = "unnamed #{is_class ? 'Class' : 'Module'}"
           end
         else
@@ -45,40 +48,14 @@ module Looksee
         end
       end
 
-      def real_module(module_or_included_class)
-        module_or_included_class
-      end
-
-      def internal_superclass(klass)
-        raise NotImplementedError, "abstract"
-      end
-
-      def internal_class(object)
-        raise NotImplementedError, "abstract"
-      end
-
-      def included_class?(object)
-        raise NotImplementedError, "abstract"
-      end
-
-      def internal_public_instance_methods(mod)
-        raise NotImplementedError, "abstract"
-      end
-
-      def internal_protected_instance_methods(mod)
-        raise NotImplementedError, "abstract"
-      end
-
-      def internal_private_instance_methods(mod)
-        raise NotImplementedError, "abstract"
-      end
-
       def internal_undefined_instance_methods(mod)
         raise NotImplementedError, "abstract"
       end
 
-      def singleton_class?(object)
-        raise NotImplementedError, "abstract"
+      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
 
       def singleton_instance(singleton_class)
@@ -86,19 +63,7 @@ module Looksee
       end
 
       def module_name(mod)
-        raise NotImplementedError, "abstract"
-      end
-
-      if RUBY_VERSION >= '1.9.0' || Looksee.ruby_engine == 'rbx'
-        def source_location(method)
-          method.is_a?(UnboundMethod) or
-            raise TypeError, "expected UnboundMethod, got #{method.class}"
-          method.source_location
-        end
-      else
-        def source_location(method)
-          raise NotImplementedError, 'abstract'
-        end
+        Looksee.safe_call(Module, :name, mod) || ''
       end
     end
   end

data/lib/looksee/adapter/rubinius.rb

@@ -4,25 +4,6 @@ require 'looksee/rbx'
 module Looksee
   module Adapter
     class Rubinius < Base
-      def internal_superclass(klass)
-        klass.direct_superclass
-      end
-
-      def internal_public_instance_methods(mod)
-        return [] if !mod.origin.equal?(mod)
-        mod.method_table.public_names
-      end
-
-      def internal_protected_instance_methods(mod)
-        return [] if !mod.origin.equal?(mod)
-        mod.method_table.protected_names
-      end
-
-      def internal_private_instance_methods(mod)
-        return [] if !mod.origin.equal?(mod)
-        mod.method_table.private_names
-      end
-
       def internal_undefined_instance_methods(mod)
         return [] if !mod.origin.equal?(mod)
         names = []
@@ -32,51 +13,11 @@ module Looksee
         names
       end
 
-      def included_class?(object)
-        object.is_a?(::Rubinius::IncludedModule)
-      end
-
-      def singleton_class?(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}"
-        ::Rubinius::Type.singleton_class_object(singleton_class)
-      end
-
-      def module_name(mod)
-        mod.is_a?(Module) or
-          raise TypeError, "expected module, got #{mod.class}"
-
-        if ::Rubinius::IncludedModule === mod
-          if Class === mod.module
-            "#{module_name(mod.module)} (origin)"
-          else
-            module_name(mod.module)
-          end
-        elsif ::Rubinius::Type.respond_to?(:module_name)
-          ::Rubinius::Type.module_name(mod) || ''
+        if Class === singleton_class && (instance = ::Rubinius::Type.singleton_class_object(singleton_class))
+          instance
         else
-          mod.__name__
-        end
-      end
-
-      def source_location(method)
-        method.is_a?(UnboundMethod) or
-          raise TypeError, "expected UnboundMethod, got #{method.class}"
-        source_location = method.source_location and
-          return source_location
-
-        # #source_location doesn't always work. If it returns nil, try
-        # a little harder.
-        case (executable = method.executable)
-        when ::Rubinius::BlockEnvironment::AsMethod
-          method = executable.instance_variable_get(:@block_env).method
-          [method.file.to_s, method.lines[1]]
-        when ::Rubinius::DelegatedMethod
-          executable.instance_variable_get(:@receiver).source_location
+          nil
         end
       end
     end

data/lib/looksee/clean.rb

@@ -15,7 +15,6 @@ module Looksee
   autoload :Help, 'looksee/help'
   autoload :Inspector, 'looksee/inspector'
   autoload :LookupPath, 'looksee/lookup_path'
-  autoload :WirbleCompatibility, 'looksee/wirble_compatibility'
 
   class << self
     #
@@ -138,6 +137,11 @@ module Looksee
     def help
       Help.new
     end
+
+    # Call mod#method on receiver, ignoring any overrides in receiver's class.
+    def safe_call(mod, name, receiver, *args) # :nodoc:
+      mod.instance_method(name).bind(receiver).call(*args)
+    end
   end
 
   self.default_specifiers = [:public, :protected, :private, :undefined, :overridden]

data/lib/looksee/editor.rb

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

data/lib/looksee/help.rb

@@ -4,7 +4,8 @@ module Looksee
       <<-EOS.gsub(/^ *\|/, '')
         |== Looksee Quick Reference
         |
-        |  object.ls(*specifiers)  or  Looksee[object, *specifiers]
+        |  \e[1mobject.ls(*specifiers)\e[0m  or  \e[1mLooksee[object, *specifiers]\e[0m
+        |
         |    Print the methods of \`object\'.
         |
         |    Available specifiers:
@@ -40,7 +41,7 @@ module Looksee
         |          ...
         |        }
         |
-        |  object.ls.edit(method)
+        |  \e[1mobject.ls.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/lookup_path.rb

@@ -28,7 +28,7 @@ module Looksee
         if visibility == :undefined
           return nil
         else
-          return Looksee.adapter.real_module(entry.module).instance_method(name)
+          return Looksee.safe_call(Module, :instance_method, entry.module, name)
         end
       end
       nil
@@ -83,11 +83,15 @@ module Looksee
 
       def find_methods
         methods = {}
-        [:public, :protected, :private, :undefined].each do |visibility|
-          Looksee.adapter.send("internal_#{visibility}_instance_methods", @module).each do |method|
+        [:public, :protected, :private].each do |visibility|
+          meths = Looksee.safe_call(Module, "#{visibility}_instance_methods", @module, false)
+          meths.each do |method|
             methods[method.to_s] = visibility
           end
         end
+        Looksee.adapter.send("internal_undefined_instance_methods", @module).each do |method|
+          methods[method.to_s] = :undefined
+        end
         methods
       end
     end

data/lib/looksee/version.rb

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

data/spec/looksee/adapter_spec.rb

@@ -30,15 +30,11 @@ describe "Looksee.adapter" do
       junk_patterns = [
         # pollution from testing libraries
         'Mocha', 'Spec',
-        # RSpec adds this under ruby 1.8.6
-        'InstanceExecHelper',
         # RSpec 2
         'RSpec::',
-        # only in ruby 1.9
-        'BasicObject',
-        # something pulls this in under ruby 1.9
+        # not sure what pulls this in
         'PP',
-        # our own pollution,
+        # our own pollution
         'Looksee::ObjectMixin',
       ]
       pattern = /\b(#{junk_patterns.join('|')})\b/
@@ -53,22 +49,22 @@ describe "Looksee.adapter" do
         include Mod1
         include Mod2
       end
-      filtered_lookup_modules(Derived.new) ==
-        ['Derived', 'Mod2', 'Mod1', 'Base', 'Object', 'Kernel']
+      filtered_lookup_modules(Derived.new).should ==
+        ['Derived', 'Mod2', 'Mod1', 'Base', 'Object', 'Kernel', 'BasicObject']
     end
 
-    it "should contain an entry for the object's singleton class if it exists" do
+    it "should contain an entry for the object's singleton class if it has methods" do
       object = Object.new
-      object.singleton_class
+      def object.f; end
 
       filtered_lookup_modules(object).should ==
-        ['[Object instance]', 'Object', 'Kernel']
+        ['[Object instance]', 'Object', 'Kernel', 'BasicObject']
     end
 
     it "should contain entries for singleton classes of all ancestors for class objects" do
       temporary_class :C
       filtered_lookup_modules(C).should ==
-        ['[C]', '[Object]', 'Class', 'Module', 'Object', 'Kernel']
+        ['[C]', '[Object]', '[BasicObject]', 'Class', 'Module', 'Object', 'Kernel', 'BasicObject']
     end
 
     it "should work for immediate objects" do
@@ -81,193 +77,60 @@ describe "Looksee.adapter" do
       define_method(:target_method){name}
     end
 
-    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
-        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
-        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
-        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
-        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
-
-      it "should not return undefined methods" do
-        temporary_class :C
-        add_methods C, visibility => [:removed]
-        C.send(:undef_method, :removed)
-        @adapter.send(target_method, C).to_set.should == Set[]
-      end
-
-      if RUBY_VERSION >= '2'
-        it "should return methods only for origin classes" do
+    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, visibility => :one
-          temporary_module :M
-          add_methods M, visibility => :one
-          C.send(:prepend, M)
-          @adapter.send(target_method, C).should be_empty
-
-          origin = @adapter.lookup_modules(C.new).
-            find { |mod| @adapter.describe_module(mod) == 'C (origin)' }
-          @adapter.send(target_method, origin).should_not be_empty
+          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
-      end
-    end
-
-    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
-        add_methods C, {visibility1 => [:a], visibility2 => [:b]}
-        @adapter.send(target_method, C).to_set.should == Set[]
-      end
-    end
-
-    describe ".internal_public_instance_methods" do
-      target_method :internal_public_instance_methods
-      it_should_list_methods_with_visibility :public
-      it_should_not_list_methods_with_visibility :private, :protected
-    end
-
-    describe ".internal_protected_instance_methods" do
-      target_method :internal_protected_instance_methods
-      it_should_list_methods_with_visibility :protected
-      it_should_not_list_methods_with_visibility :public, :private
-    end
-
-    describe ".internal_private_instance_methods" do
-      target_method :internal_private_instance_methods
-      it_should_list_methods_with_visibility :private
-      it_should_not_list_methods_with_visibility :public, :protected
-    end
-
-    describe ".internal_undefined_instance_methods" do
-      it "should return the list of undefined instance methods directly on a class" do
-        temporary_class :C
-        C.send(:define_method, :f){}
-        C.send(:undef_method, :f)
-        @adapter.internal_undefined_instance_methods(C).should == [:f]
-      end
-
-      it "should return the list of undefined instance methods directly on a module" do
-        temporary_module :M
-        M.send(:define_method, :f){}
-        M.send(:undef_method, :f)
-        @adapter.internal_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
-        c.singleton_class.send(:define_method, :f){}
-        c.singleton_class.send(:undef_method, :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
-        C.singleton_class.send(:define_method, :f){}
-        C.singleton_class.send(:undef_method, :f)
-        @adapter.internal_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 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 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 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 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 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
 
-      if RUBY_VERSION >= '2'
-        it "should return an empty list for non-origin classes" do
+        it "should not return defined methods" do
           temporary_class :C
           C.send(:define_method, :f){}
-          C.send(:undef_method, :f)
-          temporary_module :M
-          M.send(:define_method, :f){}
-          M.send(:undef_method, :f)
-          C.send(:prepend, M)
+          @adapter.internal_undefined_instance_methods(C).should == []
+        end
 
-          @adapter.internal_undefined_instance_methods(C).should be_empty
+        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
 
-          origin = @adapter.lookup_modules(C.new).
-            find { |mod| @adapter.describe_module(mod) == 'C (origin)' }
-          @adapter.internal_undefined_instance_methods(origin).should_not be_empty
+        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
   end
 
-  describe "#singleton_class?" do
-    it "should return true if the object is a singleton class of an object" do
-      object = (class << Object.new; self; end)
-      @adapter.singleton_class?(object).should == true
-    end
-
-    it "should return true if the object is a singleton class of a class" do
-      object = (class << Class.new; self; end)
-      @adapter.singleton_class?(object).should == true
-    end
-
-    it "should return true if the object is a singleton class of a singleton class" do
-      object = (class << (class << Class.new; self; end); self; end)
-      @adapter.singleton_class?(object).should == true
-    end
-
-    it "should return false if the object is just a class" do
-      object = Class.new
-      @adapter.singleton_class?(object).should == false
-    end
-
-    it "should return false if the object is just a module" do
-      object = Module.new
-      @adapter.singleton_class?(object).should == false
-    end
-
-    it "should return false if the object is just an object" do
-      object = Object.new
-      @adapter.singleton_class?(object).should == false
-    end
-
-    it "should return false if the object is TrueClass" do
-      @adapter.singleton_class?(TrueClass).should == false
-    end
-
-    it "should return false if the object is FalseClass" do
-      @adapter.singleton_class?(FalseClass).should == false
-    end
-
-    it "should return false if the object is NilClass" do
-      @adapter.singleton_class?(NilClass).should == false
-    end
-  end
-
   describe "singleton_instance" do
     it "should return the instance of the given singleton class" do
       object = Object.new
@@ -284,88 +147,48 @@ describe "Looksee.adapter" do
       @adapter.singleton_instance((class << mod; self; end)).should equal(mod)
     end
 
-    it "should raise a TypeError if the given object is just a class" do
-      lambda do
-        @adapter.singleton_instance(Class.new)
-      end.should raise_error(TypeError)
+    it "should return the instance of the given singleton class singleton class" do
+      singleton_class = (class << Class.new; self; end)
+      super_singleton_class = (class << singleton_class; self; end)
+      @adapter.singleton_instance(super_singleton_class).should equal(singleton_class)
     end
 
-    it "should raise a TypeError if the given object is just a module" do
-      lambda do
-        @adapter.singleton_instance(Module.new)
-      end.should raise_error(TypeError)
+    it "should return nil if the given object is just a class" do
+      @adapter.singleton_instance(Class.new).should be_nil
     end
 
-    it "should raise a TypeError if the given object is just a object" do
-      lambda do
-        @adapter.singleton_instance(Object.new)
-      end.should raise_error(TypeError)
+    it "should return nil if the given object is just a module" do
+      @adapter.singleton_instance(Module.new).should be_nil
     end
-  end
 
-  describe "#module_name" do
-    it "should return the fully-qualified name of the given module" do
-      ::M = Module.new
-      M::N = Module.new
-      begin
-        @adapter.module_name(M::N).should == 'M::N'
-      ensure
-        Object.send :remove_const, :M
-      end
+    it "should return nil if the given object is just a object" do
+      @adapter.singleton_instance(Object.new).should be_nil
     end
 
-    it "should return the fully-qualified name of the given class" do
-      ::M = Module.new
-      M::C = Class.new
-      begin
-        @adapter.module_name(M::C).should == 'M::C'
-      ensure
-        Object.send :remove_const, :M
-      end
+    it "should return nil if the given object is an immediate object" do
+      @adapter.singleton_instance(nil).should be_nil
+      @adapter.singleton_instance(true).should be_nil
+      @adapter.singleton_instance(false).should be_nil
+      @adapter.singleton_instance(1).should be_nil
+      @adapter.singleton_instance(:hi).should be_nil
     end
+  end
 
-    it "should not be affected by overridding the module's #to_s or #name" do
+  describe "#describe_module" do
+    it "should return the fully-qualified name of a module" do
       begin
         ::M = Module.new
-        ::M::C = Class.new do
-          def name
-            'overridden'
-          end
-          def to_s
-            'overridden'
-          end
-        end
-        @adapter.describe_module(M::C).should == 'M::C'
+        ::M::N = Module.new
+        @adapter.describe_module(::M::N).should == 'M::N'
       ensure
         Object.send :remove_const, :M
       end
     end
 
-    it "should return an empty string for unnamed modules" do
-      @adapter.module_name(Module.new).should == ''
-    end
-
-    it "should return an empty string for unnamed classes" do
-      @adapter.module_name(Class.new).should == ''
-    end
-
-    it "should return an empty string for singleton classes" do
-      object = Object.new
-      @adapter.module_name((class << object; self; end)).should == ''
-    end
-
-    it "should raise a TypeError if the argumeent is not a module" do
-      lambda do
-        @adapter.module_name(Object.new)
-      end.should raise_error(TypeError)
-    end
-  end
-
-  describe "#describe_module" do
-    it "should return the fully-qualified name of a module" do
+    it "should return the fully-qualified name of a class" do
       begin
         ::M = Module.new
-        ::M::N = Module.new
+        ::M::N = Class.new
         @adapter.describe_module(::M::N).should == 'M::N'
       ensure
         Object.send :remove_const, :M
@@ -462,126 +285,10 @@ describe "Looksee.adapter" do
         end
       end
     end
-  end
-
-  describe "#source_location" do
-    def load_source(source)
-      @tmp = "#{ROOT}/spec/tmp"
-      # 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
-      @source_path
-    end
-
-    after do
-      FileUtils.rm_rf @tmp if @tmp
-      Object.send(:remove_const, :C) if Object.const_defined?(:C)
-    end
-
-    it "should return the file and line number the given method was defined on" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |end
-      EOS
-      method = C.instance_method(:f)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should work for methods defined via a block (MRI BMETHOD)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  define_method :f do
-        |  end
-        |end
-      EOS
-      method = C.instance_method(:f)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should work for methods defined via a proc (MRI BMETHOD)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  f = lambda do
-        |  end
-        |  define_method :f, f
-        |end
-      EOS
-      method = C.instance_method(:f)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should work for methods defined via a UnboundMethod (MRI DMETHOD)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |  define_method :g, instance_method(:f)
-        |end
-      EOS
-      method = C.instance_method(:g)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should work for methods defined via a BoundMethod (MRI DMETHOD)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |  define_method :g, new.method(:f)
-        |end
-      EOS
-      method = C.instance_method(:g)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should work for methods whose visibility is overridden in a subclass (MRI ZSUPER)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |end
-        |class D < C
-        |  private :f
-        |end
-      EOS
-      begin
-        method = D.instance_method(:f)
-        @adapter.source_location(method).should == [path, 2]
-      ensure
-        Object.send(:remove_const, :D)
-      end
-    end
-
-    it "should work for aliases (MRI FBODY)" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |  alias g f
-        |end
-      EOS
-      method = C.instance_method(:g)
-      @adapter.source_location(method).should == [path, 2]
-    end
-
-    it "should return nil for primitive methods (MRI CBODY)" do
-      method = String.instance_method(:bytesize)
-      @adapter.source_location(method).should == nil
-    end
 
-    it "should raise a TypeError if the argument is not an UnboundMethod" do
-      path = load_source <<-EOS.demargin
-        |class C
-        |  def f
-        |  end
-        |end
-      EOS
+    it "should raise a TypeError if the argumeent is not a module" do
       lambda do
-        @adapter.source_location(nil)
+        @adapter.describe_module(Object.new)
       end.should raise_error(TypeError)
     end
   end