looksee 0.2.1 → 1.0.0

data/lib/looksee/help.rb

@@ -0,0 +1,54 @@
+module Looksee
+  class Help
+    def inspect
+      <<-EOS.gsub(/^ *\|/, '')
+        |== Looksee Quick Reference
+        |
+        |  object.ls(*specifiers)
+        |    Print the methods of \`object\'.
+        |
+        |    Available specifiers:
+        |
+        |      :public     :private    :overridden
+        |      :protected  :undefined
+        |        Print methods with these visibilities.
+        |
+        |      :nopublic     :noprivate    :nooverridden
+        |      :noprotected  :noundefined
+        |        Do not print methods with these visibilities.
+        |
+        |      "string"
+        |        Print methods containing this string.
+        |
+        |      /regexp/
+        |        Print methods matching this regexp.
+        |
+        |    Styles:
+        |
+        |      #{Looksee.styles[:module] % 'Module'}
+        |      #{Looksee.styles[:public] % 'public'}     }
+        |      #{Looksee.styles[:protected] % 'protected'}  } like a traffic light!
+        |      #{Looksee.styles[:private] % 'private'}    }
+        |      #{Looksee.styles[:undefined] % 'undefined'}  ] like a ghost!
+        |      #{Looksee.styles[:overridden] % 'overridden'} ] like a shadow!
+        |
+        |      Customize with Looksee.styles:
+        |
+        |        Looksee.styles = {
+        |          :module => '**%s**',
+        |          :private => '(%s)',
+        |          ...
+        |        }
+        |
+        |  object.edit(method)
+        |
+        |    Jump to the source of the given method. Set your editor
+        |    with Looksee.editor or the LOOKSEE_EDITOR environment
+        |    variable. "%f" expands to the file name, "%l" to the line
+        |    number. Example:
+        |
+        |    Looksee.editor = "emacs -nw +%f %l"
+      EOS
+    end
+  end
+end

data/lib/looksee/inspector.rb

@@ -0,0 +1,55 @@
+module Looksee
+  class Inspector
+    def initialize(lookup_path, options={})
+      @lookup_path = lookup_path
+      @visibilities = (vs = options[:visibilities]) ? vs.to_set : Set[]
+      @filters = (fs = options[:filters]) ? fs.to_set : Set[]
+      @width = options[:width] || ENV['COLUMNS'].to_i.nonzero? || Looksee.default_width
+    end
+
+    attr_reader :lookup_path
+    attr_reader :visibilities
+    attr_reader :filters
+
+    def inspect
+      lookup_path.entries.reverse.map do |entry|
+        inspect_entry(entry)
+      end.join("\n")
+    end
+
+    private
+
+    def inspect_entry(entry)
+      string = styled_module_name(entry) << "\n"
+      string << Columnizer.columnize(styled_methods(entry), @width)
+      string.chomp
+    end
+
+    def styled_module_name(entry)
+      Looksee.styles[:module] % Looksee.adapter.describe_module(entry.module)
+    end
+
+    def styled_methods(entry)
+      pattern = filter_pattern
+      show_overridden = @visibilities.include?(:overridden)
+      entry.map do |name, visibility|
+        next if !selected?(name, visibility)
+        style = entry.overridden?(name) ? :overridden : visibility
+        next if style == :overridden && !show_overridden
+        Looksee.styles[style] % name
+      end.compact
+    end
+
+    def filter_pattern
+      strings = filters.grep(String)
+      regexps = filters.grep(Regexp)
+      string_patterns = strings.map{|s| Regexp.escape(s)}
+      regexp_patterns = regexps.map{|s| s.source}
+      /#{(string_patterns + regexp_patterns).join('|')}/
+    end
+
+    def selected?(name, visibility)
+      @visibilities.include?(visibility) && name =~ filter_pattern
+    end
+  end
+end

data/lib/looksee/lookup_path.rb

@@ -0,0 +1,95 @@
+module Looksee
+  #
+  # Represents the method lookup path of an object, as a list of
+  # Entries.
+  #
+  class LookupPath
+    def initialize(object)
+      @object = object
+      @entries = create_entries
+    end
+
+    #
+    # The object this lookup path represents.
+    #
+    attr_reader :object
+
+    #
+    # List of Entry objects, each one representing a Module in the
+    # lookup path.
+    #
+    attr_reader :entries
+
+    def find(name)
+      entries.each do |entry|
+        visibility = entry.methods[name] or
+          next
+
+        if visibility == :undefined
+          return nil
+        else
+          return entry.module.instance_method(name)
+        end
+      end
+      nil
+    end
+
+    #
+    # Return a string showing the object's lookup path.
+    #
+    def inspect(options={})
+      Inspector.new(self, options).inspect
+    end
+
+    private  # -------------------------------------------------------
+
+    def create_entries
+      seen = Set.new
+      Looksee.adapter.lookup_modules(object).map do |mod|
+        entry = Entry.new(mod, seen)
+        seen += entry.methods.keys
+        entry
+      end
+    end
+
+    #
+    # An entry in the LookupPath.
+    #
+    class Entry
+      def initialize(mod, overridden)
+        @module = mod
+        @methods = find_methods
+        @overridden = overridden
+      end
+
+      attr_reader :module, :methods
+
+      def overridden?(name)
+        @overridden.include?(name.to_s)
+      end
+
+      #
+      # Yield each method in alphabetical order along with its
+      # visibility (:public, :private, :protected, :undefined, or
+      # :overridden).
+      #
+      def each(&block)
+        @methods.sort.each(&block)
+      end
+
+      include Enumerable
+
+      private  # -----------------------------------------------------
+
+      def find_methods
+        methods = {}
+        [:public, :protected, :private, :undefined].each do |visibility|
+          Looksee.adapter.send("internal_#{visibility}_instance_methods", @module).each do |method|
+            methods[method.to_s] = visibility
+          end
+        end
+        methods
+      end
+    end
+  end
+end

data/lib/looksee/shortcuts.rb

@@ -1,107 +1,3 @@
-=begin
-
-Include this to pollute the standard ruby modules with handy aliases.
-Perfect for your .irbrc, or for punching into your program to work out
-what that +flazbot+ variable can do.
-
-=end
-
 require 'looksee'
 
-class Object
-  private  # ---------------------------------------------------------
-
-  #
-  # Alias for Looksee.lookup_path.
-  #
-  # (Added by Looksee.)
-  #
-  def lp(*args)
-    Looksee.lookup_path(*args)
-  end
-
-  #
-  # Run Looksee.lookup_path on an instance of the given class.
-  #
-  # (Added by Looksee.)
-  #
-  def lpi(klass, *args)
-    Looksee.lookup_path(klass.allocate, *args)
-  end
-
-  public  # ----------------------------------------------------------
-
-  #
-  # Call Looksee.lookup_path on this object.
-  #
-  # (Added by Looksee.)
-  #
-  def lookup_path(*args)
-    Looksee.lookup_path(self, *args)
-  end
-
-  #
-  # Dump the lookup path to standard output, and return self.
-  #
-  # Good for stuffing in a call chain.
-  #
-  # (Added by Looksee.)
-  #
-  def dump_lookup_path(*args)
-    p lookup_path(*args)
-    self
-  end
-end
-
-module Looksee
-  #
-  # Show a quick reference.
-  #
-  def self.help
-    Help.new
-  end
-
-  class Help
-    def inspect
-      <<-EOS.gsub(/^ *\|/, '')
-        |== Looksee Quick Reference
-        |
-        |  lp(object)
-        |  object.lookup_path
-        |    Print the method lookup path of \`object\'
-        |
-        |  lpi(klass)
-        |    Print the method lookup path of an instance of \`klass\'.
-        |
-        |Add .grep(/pattern/) to restrict the methods listed:
-        |
-        |  lp(object).grep(/foo/)
-        |
-        |== Visibilities
-        |
-        |Methods are printed according to their visibility:
-        |
-        |#{style_info}
-        |
-        |Pass options to specify which visibilities to show:
-        |
-        |  lp(object, :private => true, :overridden => false)
-        |  lp(object, :private        , :overridden => false)  # shortcut
-      EOS
-    end
-
-    def style_info
-      max_width = 0
-      styles = [:public, :protected, :private, :undefined, :overridden]
-      data = styles.map do |name|
-        display_style = Looksee.styles[name] % name
-        display_length = display_style.length
-        max_width = display_length if display_length > max_width
-        on = Looksee.default_lookup_path_options[name] ? 'on' : 'off'
-        [display_style, on]
-      end.map do |display_style, on|
-        "  * #{display_style.ljust(max_width)}  (#{on} by default)"
-      end.join("\n")
-    end
-  end
-end
+warn "'looksee/shortcuts' is deprecated; please require 'looksee' instead."

data/lib/looksee/version.rb

@@ -1,3 +1,11 @@
 module Looksee
-  VERSION = '0.2.1'
+  VERSION = [1, 0, 0]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
 end

data/lib/looksee/wirble_compatibility.rb

@@ -8,6 +8,7 @@ module Looksee
       end
 
       def wirble_colorizing?
+        require 'irb'
         IRB::Irb.method_defined?(:non_color_output_value)
       end
 
@@ -39,7 +40,7 @@ module Looksee
         IRB::Irb.class_eval do
           def output_value_with_looksee
             case @context.last_value
-            when Looksee::LookupPath, Looksee::Help
+            when Looksee::Inspector, Looksee::Help
               non_color_output_value
             else
               output_value_without_looksee
@@ -83,5 +84,3 @@ module Looksee
     end
   end
 end
-
-Looksee::WirbleCompatibility.init

data/spec/adapter_spec.rb

@@ -0,0 +1,546 @@
+require 'spec_helper'
+
+describe "Looksee.adapter" do
+  include TemporaryClasses
+
+  before do
+    @adapter = NATIVE_ADAPTER
+  end
+
+  describe "#lookup_modules" do
+    #
+    # Filter out modules which are hard to test against, and returns
+    # the list of module names.  #inspect strings are used for names
+    # of singleton classes, since they have no name.
+    #
+    def filtered_lookup_modules(object)
+      result = @adapter.lookup_modules(object)
+      result.select{ |mod| deterministic_module?(mod) }
+    end
+
+    #
+    # Return true if the given module name is of a module we can test
+    # for.
+    #
+    # This excludes ruby version dependent modules, and modules tossed
+    # into the hierarchy by testing frameworks.
+    #
+    def deterministic_module?(mod)
+      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
+        'PP',
+        # our own pollution,
+        'Looksee::Object',
+      ]
+      pattern = /\A(#{junk_patterns.join('|')})/
+
+      # Singleton classes of junk are junk.
+      if Looksee.ruby_engine == 'rbx'
+        # Rubinius singleton class #inspect strings aren't formatted
+        # like the others.
+        while mod.respond_to?(:__metaclass_object__) && (object = mod.__metaclass_object__).is_a?(Class)
+          mod = object
+        end
+        mod.name !~ pattern
+      else
+        name = mod.to_s
+        while name =~ /\A#<Class:(.*)>\z/
+          name = $1
+        end
+        name !~ pattern
+      end
+    end
+
+    it "should contain an entry for each module in the object's lookup path" do
+      temporary_module :Mod1
+      temporary_module :Mod2
+      temporary_class :Base
+      temporary_class :Derived, :superclass => Base do
+        include Mod1
+        include Mod2
+      end
+      filtered_lookup_modules(Derived.new) == [Derived, Mod2, Mod1, Base, Object, Kernel]
+    end
+
+    it "should contain an entry for the object's singleton class if it exists" do
+      object = Object.new
+      object.singleton_class
+
+      filtered_lookup_modules(object).should == [object.singleton_class, Object, Kernel]
+    end
+
+    it "should contain entries for singleton classes of all ancestors for class objects" do
+      temporary_class :C
+      filtered_lookup_modules(C).should == [C.singleton_class, Object.singleton_class, Class, Module, Object, Kernel]
+    end
+
+    it "should work for immediate objects" do
+      filtered_lookup_modules(1).first.should == Fixnum
+    end
+  end
+
+  describe "internal instance methods:" do
+    def self.target_method(name)
+      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
+        replace_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]
+        @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]
+        @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
+        @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]
+        C.send(:undef_method, :removed)
+        @adapter.send(target_method, C).to_set.should == Set[]
+      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
+        replace_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 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
+    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 be_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 be_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 be_true
+    end
+
+    it "should return false if the object is just a class" do
+      object = Class.new
+      @adapter.singleton_class?(object).should be_false
+    end
+
+    it "should return false if the object is just a module" do
+      object = Module.new
+      @adapter.singleton_class?(object).should be_false
+    end
+
+    it "should return false if the object is just an object" do
+      object = Object.new
+      @adapter.singleton_class?(object).should be_false
+    end
+
+    it "should return false if the object is TrueClass" do
+      @adapter.singleton_class?(TrueClass).should be_false
+    end
+
+    it "should return false if the object is FalseClass" do
+      @adapter.singleton_class?(FalseClass).should be_false
+    end
+
+    it "should return false if the object is NilClass" do
+      @adapter.singleton_class?(NilClass).should be_false
+    end
+  end
+
+  describe "singleton_instance" do
+    it "should return the instance of the given singleton class" do
+      object = Object.new
+      @adapter.singleton_instance((class << object; self; end)).should equal(object)
+    end
+
+    it "should return the instance of the given class singleton class" do
+      klass = Class.new
+      @adapter.singleton_instance((class << klass; self; end)).should equal(klass)
+    end
+
+    it "should return the instance of the given module singleton class" do
+      mod = Module.new
+      @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)
+    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)
+    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)
+    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
+    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
+    end
+
+    it "should not be affected by overridding the module's #to_s or #name" 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'
+      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
+      begin
+        ::M = Module.new
+        ::M::N = Module.new
+        @adapter.describe_module(::M::N).should == 'M::N'
+      ensure
+        Object.send :remove_const, :M
+      end
+    end
+
+    it "should not be affected by overridding the module's #to_s or #name" 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'
+      ensure
+        Object.send :remove_const, :M
+      end
+    end
+
+    describe "for an unnamed class" do
+      it "should describe the object as 'unnamed Class'" do
+        @adapter.describe_module(Class.new).should == 'unnamed Class'
+      end
+    end
+
+    describe "for an unnamed module" do
+      it "should describe the object as 'unnamed Module'" do
+        @adapter.describe_module(Module.new).should == 'unnamed Module'
+      end
+    end
+
+    describe "for a singleton class of an object" do
+      it "should describe the object in brackets" do
+        begin
+          ::M = Module.new
+          ::M::C = Class.new
+          object = M::C.new
+          @adapter.describe_module(object.singleton_class).should == '[M::C instance]'
+        ensure
+          Object.send :remove_const, :M
+        end
+      end
+    end
+
+    describe "for a singleton class of a named class" do
+      it "should return the class name in brackets" do
+        begin
+          ::M = Module.new
+          ::M::C = Class.new
+          @adapter.describe_module(M::C.singleton_class).should == '[M::C]'
+        ensure
+          Object.send :remove_const, :M
+        end
+      end
+    end
+
+    describe "for a singleton class of an unnamed class" do
+      it "should describe the object as '[unnamed Class]'" do
+        klass = Class.new
+        @adapter.describe_module(klass.singleton_class).should == '[unnamed Class]'
+      end
+    end
+
+    describe "for a singleton class of an unnamed module" do
+      it "should describe the object as '[unnamed Module]'" do
+        mod = Module.new
+        @adapter.describe_module(mod.singleton_class).should == '[unnamed Module]'
+      end
+    end
+
+    describe "for a singleton class of a singleton class" do
+      it "should return the object's class name in two pairs of brackets" do
+        begin
+          ::M = Module.new
+          ::M::C = Class.new
+          klass = M::C.singleton_class.singleton_class
+          @adapter.describe_module(klass).should == '[[M::C]]'
+        ensure
+          Object.send :remove_const, :M
+        end
+      end
+    end
+  end
+
+  describe "#source_location" do
+    def load_source(source)
+      @tmp = "#{ROOT}/spec/tmp"
+      @source_path = "#@tmp/c.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
+      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 raise a TypeError if the argument is not an UnboundMethod" do
+      path = load_source <<-EOS.demargin
+        |class C
+        |  def f
+        |  end
+        |end
+      EOS
+      lambda do
+        @adapter.source_location(nil)
+      end.should raise_error(TypeError)
+    end
+  end
+end