looksee 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,10 @@
+== 0.0.2 2009-07-28
+
+* Added #grep to filter methods shown: lp(object).grep(/pattern/)
+* Fix #1: Play nice with Wirble.
+* Fix #3: Don't die when examining immediate objects (fixnum, symbol,
+  true, false, nil)
+
 == 0.0.1 2009-07-05
 
 * Hi.

data/Manifest.txt

@@ -9,10 +9,13 @@ ext/looksee/node-1.9.h
 lib/looksee.rb
 lib/looksee/shortcuts.rb
 lib/looksee/version.rb
+lib/looksee/wirble_compatibility.rb
+looksee.gemspec
 script/console
 script/destroy
 script/generate
 spec/looksee_spec.rb
 spec/spec_helper.rb
+spec/wirble_compatibility_spec.rb
 tasks/extconf.rake
 tasks/extconf/looksee.rake

data/Rakefile

@@ -6,12 +6,11 @@ require 'fileutils'
 require './lib/looksee/version'
 
 Hoe.plugin :newgem
-Hoe.plugin :cucumberfeatures
+Hoe.plugin :email  # from seattlerb - configure via ~/.hoerc
 
 $hoe = Hoe.spec 'looksee' do
   self.developer 'George Ogata', 'george.ogata@gmail.com'
   self.rubyforge_name       = self.name # TODO this is default value
-  self.description_sections = %w'description synopsis'
   # self.extra_deps         = [['activesupport','>= 2.0.2']]
   self.extra_dev_deps = [
     ['newgem', ">= #{::Newgem::VERSION}"],

data/ext/looksee/looksee.c

@@ -36,7 +36,7 @@ VALUE Looksee_internal_superclass(VALUE self, VALUE internal_class) {
  * object's birth class.
  */
 VALUE Looksee_internal_class(VALUE self, VALUE object) {
-  return RBASIC(object)->klass;
+  return CLASS_OF(object);
 }
 
 /*

data/lib/looksee.rb

@@ -77,7 +77,7 @@ module Looksee
         normalized_options[option] = true
       end
       normalized_options.update(hash_options)
-      LookupPath.new(object, normalized_options)
+      LookupPath.for(object, normalized_options)
     end
 
     #
@@ -149,6 +149,10 @@ module Looksee
   class LookupPath
     attr_reader :entries
 
+    def initialize(entries)
+      @entries = entries
+    end
+
     #
     # Create a LookupPath for the given object.
     #
@@ -160,23 +164,38 @@ module Looksee
     #   :private
     #   :overridden
     #
-    def initialize(object, options={})
-      @entries = []
-      seen = {}
-      Looksee.lookup_modules(object).each do |mod|
-        entry = Entry.new(mod, seen, options)
-        entry.methods.each{|m| seen[m] = true}
-        @entries << entry
+    def self.for(object, options={})
+      entries = entries_for(object, options)
+      new(entries)
+    end
+
+    #
+    # Return a new LookupPath which only contains names matching the
+    # given pattern.
+    #
+    def grep(pattern)
+      entries = self.entries.map do |entry|
+        entry.grep(pattern)
       end
+      self.class.new(entries)
     end
 
     def inspect(options={})
       options = normalize_inspect_options(options)
-      entries.map{|e| e.inspect(options)}.join
+      entries.map{|e| e.inspect(options)}.join("\n")
     end
 
     private  # -------------------------------------------------------
 
+    def self.entries_for(object, options)
+      seen = {}
+      Looksee.lookup_modules(object).map do |mod|
+        entry = Entry.for(mod, seen, options)
+        entry.methods.each{|m| seen[m] = true}
+        entry
+      end
+    end
+
     def normalize_inspect_options(options)
       options[:width] ||= ENV['COLUMNS'].to_i.nonzero? || Looksee.default_width
       options
@@ -189,21 +208,39 @@ module Looksee
     # information (public, private, etc.).
     #
     class Entry
-      #
-      # Don't call me, silly.  I'm just part of a LookupPath.
-      #
-      def initialize(mod, seen, options)
+      def initialize(mod, methods=[], visibilities={})
         @module = mod
-        @methods = []
-        @visibilities = {}
-        add_methods(Looksee.internal_public_instance_methods(mod).map{|sym| sym.to_s}   , :public   , seen) if options[:public   ]
-        add_methods(Looksee.internal_protected_instance_methods(mod).map{|sym| sym.to_s}, :protected, seen) if options[:protected]
-        add_methods(Looksee.internal_private_instance_methods(mod).map{|sym| sym.to_s}  , :private  , seen) if options[:private  ]
-        @methods.sort!
+        @methods = methods
+        @visibilities = visibilities
+      end
+
+      def self.for(mod, seen, options)
+        entry = new(mod)
+        entry.initialize_for(seen, options)
+        entry
       end
 
       attr_reader :module, :methods
 
+      def initialize_for(seen, options)
+        add_methods(Looksee.internal_public_instance_methods(@module).map{|sym| sym.to_s}   , :public   , seen) if options[:public   ]
+        add_methods(Looksee.internal_protected_instance_methods(@module).map{|sym| sym.to_s}, :protected, seen) if options[:protected]
+        add_methods(Looksee.internal_private_instance_methods(@module).map{|sym| sym.to_s}  , :private  , seen) if options[:private  ]
+        @methods.sort!
+      end
+
+      def grep(pattern)
+        methods = []
+        visibilities = {}
+        @methods.each do |name|
+          if name[pattern]
+            methods << name
+            visibilities[name] = @visibilities[name]
+          end
+        end
+        self.class.new(@module, methods, visibilities)
+      end
+
       #
       # Return the name of the class or module.
       #
@@ -236,7 +273,8 @@ module Looksee
       # columns.  Pass a :width option to control the output width.
       #
       def inspect(options={})
-        styled_module_name << "\n" << Columnizer.columnize(styled_methods, options[:width])
+        string = styled_module_name << "\n" << Columnizer.columnize(styled_methods, options[:width])
+        string.chomp
       end
 
       private  # -----------------------------------------------------
@@ -268,6 +306,8 @@ module Looksee
       # sequences.
       #
       def columnize(strings, width)
+        return '' if strings.empty?
+
         num_columns = 1
         layout = [strings]
         loop do
@@ -330,3 +370,5 @@ module Looksee
     end
   end
 end
+
+require 'looksee/wirble_compatibility'

data/lib/looksee/version.rb

@@ -1,3 +1,3 @@
 module Looksee
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/looksee/wirble_compatibility.rb

@@ -0,0 +1,86 @@
+module Looksee
+  module WirbleCompatibility
+    class << self
+      def wirble_loaded?
+        Object.const_defined?(:Wirble) &&
+          Wirble.is_a?(Module) &&
+          Wirble.respond_to?(:colorize)
+      end
+
+      def wirble_colorizing?
+        IRB::Irb.method_defined?(:non_color_output_value)
+      end
+
+      def hook_into_wirble_load
+        unless Object.const_defined?(:Wirble)
+          Object.const_set :Wirble, Module.new
+        end
+        Wirble.send :extend, WirbleLoadHook
+      end
+
+      def hook_into_wirble_colorize
+        class << Wirble
+          def colorize_with_looksee(*args)
+            # If this gets called twice, Wirble will fuck up the
+            # aliases.  Disable colorizing first to reset them.
+            if WirbleCompatibility.hooked_into_irb_output_value?
+              Wirble::Colorize.disable
+            end
+            colorize_without_looksee(*args)
+            WirbleCompatibility.hook_into_irb_output_value
+          end
+
+          alias colorize_without_looksee colorize
+          alias colorize colorize_with_looksee
+        end
+      end
+
+      def hook_into_irb_output_value
+        IRB::Irb.class_eval do
+          def output_value_with_looksee
+            if @context.last_value.is_a?(Looksee::LookupPath)
+              non_color_output_value
+            else
+              output_value_without_looksee
+            end
+          end
+
+          alias output_value_without_looksee output_value
+          alias output_value output_value_with_looksee
+        end
+      end
+
+      def hooked_into_irb_output_value?
+        IRB::Irb.method_defined?(:output_value_with_looksee)
+      end
+
+      def init
+        #
+        # How wirble is used:
+        #
+        #  * Wirble is required/loaded.  Defines Wirble module, with methods like Wirble.colorize.
+        #  * Wirble.init is called.  Nothing interesting.
+        #  * Wirble.colorize is called.  Hooks into IRB::Irb.output_value via an alias.
+        #
+        if !wirble_loaded?
+          hook_into_wirble_load
+        elsif !wirble_colorizing?
+          hook_into_wirble_colorize
+        else
+          hook_into_irb_output_value
+        end
+      end
+    end
+
+    module WirbleLoadHook
+      def singleton_method_added(name)
+        if name == :colorize && !respond_to?(:colorize_with_looksee)
+          WirbleCompatibility.hook_into_wirble_colorize
+        end
+        super
+      end
+    end
+  end
+end
+
+Looksee::WirbleCompatibility.init

data/looksee.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{looksee}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["George Ogata"]
+  s.date = %q{2009-07-05}
+  s.description = %q{Looksee lets you examine the method lookup path of objects in ways not
+possible in plain ruby.}
+  s.email = ["george.ogata@gmail.com"]
+  s.extensions = ["ext/looksee/extconf.rb"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
+  s.files = [".autotest", "History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "ext/looksee/extconf.rb", "ext/looksee/looksee.c", "ext/looksee/node-1.9.h", "lib/looksee.rb", "lib/looksee/shortcuts.rb", "lib/looksee/version.rb", "script/console", "script/destroy", "script/generate", "spec/looksee_spec.rb", "spec/spec_helper.rb", "tasks/extconf.rake", "tasks/extconf/looksee.rake"]
+  s.homepage = %q{http://github.com/oggy/looksee}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext/looksee"]
+  s.rubyforge_project = %q{looksee}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Looksee lets you examine the method lookup path of objects in ways not possible in plain ruby.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<newgem>, [">= 1.5.1"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.7"])
+      s.add_development_dependency(%q<mocha>, [">= 0.9.5"])
+      s.add_development_dependency(%q<hoe>, [">= 2.3.2"])
+    else
+      s.add_dependency(%q<newgem>, [">= 1.5.1"])
+      s.add_dependency(%q<rspec>, [">= 1.2.7"])
+      s.add_dependency(%q<mocha>, [">= 0.9.5"])
+      s.add_dependency(%q<hoe>, [">= 2.3.2"])
+    end
+  else
+    s.add_dependency(%q<newgem>, [">= 1.5.1"])
+    s.add_dependency(%q<rspec>, [">= 1.2.7"])
+    s.add_dependency(%q<mocha>, [">= 0.9.5"])
+    s.add_dependency(%q<hoe>, [">= 2.3.2"])
+  end
+end

data/spec/looksee_spec.rb

@@ -50,7 +50,7 @@ describe Looksee do
       temporary_module :Mod1
       temporary_module :Mod2
       temporary_class :Base
-      temporary_class :Derived, Base do
+      temporary_class :Derived, :superclass => Base do
         include Mod1
         include Mod2
       end
@@ -71,6 +71,10 @@ describe Looksee do
       result = filtered_lookup_modules(C)
       result.should == %w'#<Class:C> #<Class:Object> Class Module Object Kernel'
     end
+
+    it "should work for immediate objects" do
+      filtered_lookup_modules(1).first.should == 'Fixnum'
+    end
   end
 
   describe ".lookup_path" do
@@ -83,67 +87,26 @@ describe Looksee do
     it "should return a LookupPath object for the given object" do
       object = Object.new
       Looksee.stubs(:default_lookup_path_options).returns({})
-      Looksee::LookupPath.expects(:new).with(object, {})
+      Looksee::LookupPath.expects(:for).with(object, {})
       lookup_path = Looksee.lookup_path(object)
     end
 
     it "should allow symbol arguments as shortcuts for true options" do
       object = Object.new
       Looksee.stubs(:default_lookup_path_options).returns({})
-      Looksee::LookupPath.expects(:new).with(object, {:public => true, :overridden => true})
+      Looksee::LookupPath.expects(:for).with(object, {:public => true, :overridden => true})
       Looksee.lookup_path(object, :public, :overridden)
     end
 
     it "should merge the default options, with the symbols, and the options hash" do
       object = Object.new
       Looksee.stubs(:default_lookup_path_options).returns({:public => false, :protected => false, :private => false})
-      Looksee::LookupPath.expects(:new).with(object, {:public => false, :protected => true, :private => false})
+      Looksee::LookupPath.expects(:for).with(object, {:public => false, :protected => true, :private => false})
       Looksee.lookup_path(object, :protected, :private, :private => false)
     end
   end
 
   describe "internal instance methods:" do
-    #
-    # Remove all methods defined exactly on the given module.  As Ruby's
-    # reflection on singleton classes of classes isn't quite adequate,
-    # you need to provide a :class_singleton option when such a class is
-    # given.
-    #
-    def remove_methods(mod, opts={})
-      names = all_instance_methods(mod)
-
-      # all_instance_methods can't get just the methods on a class
-      # singleton class.  Filter out superclass methods here.
-      if opts[:class_singleton]
-        klass = ObjectSpace.each_object(mod){|klass| break klass}
-        names -= all_instance_methods(klass.superclass.singleton_class)
-      end
-
-      names.sort_by{|name| name.in?([:remove_method, :send]) ? 1 : 0}.flatten
-      names.each do |name|
-        mod.send :remove_method, name
-      end
-    end
-
-    def define_methods(mod, opts)
-      mod.module_eval do
-        [:public, :protected, :private].each do |visibility|
-          Array(opts[visibility]).each do |name|
-            define_method(name){}
-            send visibility, name
-          end
-        end
-      end
-    end
-
-    def all_instance_methods(mod)
-      names =
-        mod.public_instance_methods(false) +
-        mod.protected_instance_methods(false) +
-        mod.private_instance_methods(false)
-      names.map{|name| name.to_sym}  # they're strings in ruby <1.9
-    end
-
     def self.target_method(name)
       define_method(:target_method){name}
     end
@@ -151,38 +114,33 @@ describe Looksee 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
-        remove_methods C
-        define_methods C, visibility => [:one, :two]
+        replace_methods C, visibility => [:one, :two]
         Looksee.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
-        remove_methods M
-        define_methods M, visibility => [:one, :two]
+        replace_methods M, visibility => [:one, :two]
         Looksee.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
-        remove_methods c.singleton_class
-        define_methods c.singleton_class, visibility => [:one, :two]
+        replace_methods c.singleton_class, visibility => [:one, :two]
         Looksee.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
-        remove_methods C.singleton_class, :class_singleton => true
-        define_methods C.singleton_class, visibility => [:one, :two]
+        replace_methods C.singleton_class, visibility => [:one, :two], :class_singleton => true
         Looksee.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
-        remove_methods C
-        define_methods C, visibility => [:removed]
+        replace_methods C, visibility => [:removed]
         C.send(:undef_method, :removed)
         Looksee.send(target_method, C).to_set.should == Set[]
       end
@@ -191,8 +149,7 @@ describe Looksee 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
-        remove_methods C
-        define_methods C, {visibility1 => [:a], visibility2 => [:b]}
+        replace_methods C, {visibility1 => [:a], visibility2 => [:b]}
         Looksee.send(target_method, C).to_set.should == Set[]
       end
     end
@@ -218,31 +175,59 @@ describe Looksee do
 end
 
 describe Looksee::LookupPath do
-  before do
-    Looksee.default_lookup_path_options = {}
-  end
-
   include TemporaryClasses
 
+  def stub_methods(mod, public, protected, private)
+    Looksee.stubs(:internal_public_instance_methods   ).with(mod).returns(public)
+    Looksee.stubs(:internal_protected_instance_methods).with(mod).returns(protected)
+    Looksee.stubs(:internal_private_instance_methods  ).with(mod).returns(private)
+  end
+
   describe "#entries" do
     it "should contain an entry for each module in the object's lookup path" do
       object = Object.new
       temporary_class :C
       temporary_class :D
       Looksee.stubs(:lookup_modules).with(object).returns([C, D])
-      Looksee::LookupPath.new(object).entries.map{|entry| entry.module_name}.should == %w'C D'
+      Looksee::LookupPath.for(object).entries.map{|entry| entry.module_name}.should == %w'C D'
+    end
+  end
+
+  describe "grep" do
+    it "should only include methods matching the given regexp" do
+      temporary_class :C
+      temporary_class :D
+      stub_methods(C, ['axbyc', 'xy'], [], [])
+      stub_methods(D, ['axbyc', 'xdy'], [], [])
+      object = Object.new
+      Looksee.stubs(:lookup_modules).with(object).returns([C, D])
+      lookup_path = Looksee::LookupPath.for(object, :public => true, :overridden => true).grep(/x.y/)
+      lookup_path.entries.map{|entry| entry.module_name}.should == %w'C D'
+      lookup_path.entries[0].methods.to_set.should == Set['axbyc']
+      lookup_path.entries[1].methods.to_set.should == Set['axbyc', 'xdy']
+    end
+
+    it "should only include methods including the given string" do
+      temporary_class :C
+      temporary_class :D
+      stub_methods(C, ['axxa', 'axa'], [], [])
+      stub_methods(D, ['bxxb', 'axxa'], [], [])
+      object = Object.new
+      Looksee.stubs(:lookup_modules).with(object).returns([C, D])
+      lookup_path = Looksee::LookupPath.for(object, :public => true, :overridden => true).grep('xx')
+      lookup_path.entries.map{|entry| entry.module_name}.should == %w'C D'
+      lookup_path.entries[0].methods.to_set.should == Set['axxa']
+      lookup_path.entries[1].methods.to_set.should == Set['axxa', 'bxxb']
     end
   end
 
   describe "#inspect" do
     before do
-      Looksee.stubs(:styles).returns(Hash.new{'%s'})
+      Looksee.stubs(:default_lookup_path_options).returns({})
     end
 
-    def stub_methods(mod, public, protected, private)
-      Looksee.stubs(:internal_public_instance_methods   ).with(mod).returns(public)
-      Looksee.stubs(:internal_protected_instance_methods).with(mod).returns(protected)
-      Looksee.stubs(:internal_private_instance_methods  ).with(mod).returns(private)
+    before do
+      Looksee.stubs(:styles).returns(Hash.new{'%s'})
     end
 
     describe "contents" do
@@ -258,8 +243,8 @@ describe Looksee::LookupPath do
       end
 
       it "should show only public instance methods when only public methods are requested" do
-        lookup_path = Looksee::LookupPath.new(@object, :public => true, :overridden => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(@object, :public => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |C
           |  public1  public2
           |M
@@ -268,8 +253,8 @@ describe Looksee::LookupPath do
       end
 
       it "should show modules and protected instance methods when only protected methods are requested" do
-        lookup_path = Looksee::LookupPath.new(@object, :protected => true, :overridden => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(@object, :protected => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |C
           |  protected1  protected2
           |M
@@ -278,8 +263,8 @@ describe Looksee::LookupPath do
       end
 
       it "should show modules and private instance methods when only private methods are requested" do
-        lookup_path = Looksee::LookupPath.new(@object, :private => true, :overridden => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(@object, :private => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |C
           |  private1  private2
           |M
@@ -288,8 +273,8 @@ describe Looksee::LookupPath do
       end
 
       it "should show modules with public and private instance methods when only public and private methods are requested" do
-        lookup_path = Looksee::LookupPath.new(@object, :public => true, :private => true, :overridden => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(@object, :public => true, :private => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |C
           |  private1  private2  public1  public2
           |M
@@ -300,8 +285,8 @@ describe Looksee::LookupPath do
       it "should show singleton classes as class names in brackets" do
         Looksee.stubs(:lookup_modules).with(C).returns([C.singleton_class])
         stub_methods(C.singleton_class, ['public1', 'public2'], [], [])
-        lookup_path = Looksee::LookupPath.new(C, :public => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(C, :public => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |[C]
           |  public1  public2
         EOS
@@ -310,12 +295,22 @@ describe Looksee::LookupPath do
       it "should handle singleton classes of singleton classes correctly" do
         Looksee.stubs(:lookup_modules).with(C.singleton_class).returns([C.singleton_class.singleton_class])
         stub_methods(C.singleton_class.singleton_class, ['public1', 'public2'], [], [])
-        lookup_path = Looksee::LookupPath.new(C.singleton_class, :public => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(C.singleton_class, :public => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |[[C]]
           |  public1  public2
         EOS
       end
+
+      it "should not show any blank lines if a module has no methods" do
+        stub_methods(C, [], [], [])
+        lookup_path = Looksee::LookupPath.for(@object, :public => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
+          |C
+          |M
+          |  public1  public2
+        EOS
+      end
     end
 
     describe "styles" do
@@ -334,8 +329,8 @@ describe Looksee::LookupPath do
         temporary_class :C
         Looksee.stubs(:lookup_modules).returns([C])
         stub_methods(C, ['public'], ['protected'], ['private'])
-        lookup_path = Looksee::LookupPath.new(Object.new, :public => true, :protected => true, :private => true, :overridden => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(Object.new, :public => true, :protected => true, :private => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |\`C\'
           |  <private>  [protected]  {public}
         EOS
@@ -347,8 +342,8 @@ describe Looksee::LookupPath do
         temporary_class :C
         Looksee.stubs(:lookup_modules).returns([C])
         stub_methods(C, %w'aa b c dd ee f g hh i', [], [])
-        lookup_path = Looksee::LookupPath.new(Object.new, :public => true)
-        lookup_path.inspect(:width => 20).should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(Object.new, :public => true)
+        lookup_path.inspect(:width => 20).should == <<-EOS.demargin.chomp
           |C
           |  aa  c   ee  g   i
           |  b   dd  f   hh
@@ -361,8 +356,8 @@ describe Looksee::LookupPath do
         Looksee.stubs(:lookup_modules).returns([A, B])
         stub_methods(A, ['a', 'long_long_long_long_name'], [], [])
         stub_methods(B, ['long_long_long', 'short'], [], [])
-        lookup_path = Looksee::LookupPath.new(Object.new, :public => true)
-        lookup_path.inspect.should == <<-EOS.demargin
+        lookup_path = Looksee::LookupPath.for(Object.new, :public => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |A
           |  a  long_long_long_long_name
           |B

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@ require 'spec'
 require 'mocha'
 require 'looksee'
 
+require 'rbconfig'
 require 'set'
 
 Spec::Runner.configure do |config|
@@ -59,8 +60,8 @@ module TemporaryClasses
   #
   # Create a temporary class with the given name and superclass.
   #
-  def temporary_class(name, superclass=Object, &block)
-    klass = Class.new(superclass)
+  def temporary_class(name, options={}, &block)
+    klass = Class.new(options[:superclass] || Object)
     Object.const_set(name, klass)
     klass.class_eval(&block) if block
     @temporary_modules << klass
@@ -77,4 +78,62 @@ module TemporaryClasses
     @temporary_modules << mod
     mod
   end
+
+  #
+  # Remove all methods defined exactly on the given module.
+  #
+  # As Ruby's reflection on singleton classes of classes isn't quite
+  # adequate, you need to provide a :class_singleton option when such
+  # a class is given.
+  #
+  def remove_methods(mod, opts={})
+    names = all_instance_methods(mod)
+
+    # all_instance_methods can't get just the methods on a class
+    # singleton class.  Filter out superclass methods here.
+    if opts[:class_singleton]
+      klass = ObjectSpace.each_object(mod){|klass| break klass}
+      names -= all_instance_methods(klass.superclass.singleton_class)
+    end
+
+    names.sort_by{|name| name.in?([:remove_method, :send]) ? 1 : 0}.flatten
+    names.each do |name|
+      mod.send :remove_method, name
+    end
+  end
+
+  #
+  # Replace the methods of the given module with those named.
+  #
+  # +methods+ is a hash of visibilities to names.
+  #
+  # As Ruby's reflection on singleton classes of classes isn't quite
+  # adequate, you need to provide a :class_singleton option when such
+  # a class is given.
+  #
+  # e.g.:
+  #
+  #   replace_methods MyClass, :public => [:a, :b]
+  #
+  def replace_methods(mod, options={})
+    remove_methods(mod, options)
+    mod.module_eval do
+      [:public, :protected, :private].each do |visibility|
+        Array(options[visibility]).each do |name|
+          define_method(name){}
+          send visibility, name
+        end
+      end
+    end
+  end
+
+  private  # ---------------------------------------------------------
+
+  def all_instance_methods(mod)
+    names =
+      mod.public_instance_methods(false) +
+      mod.protected_instance_methods(false) +
+      mod.private_instance_methods(false)
+    names.map{|name| name.to_sym}  # they're strings in ruby <1.9
+  end
 end

data/spec/wirble_compatibility_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+gem 'wirble'  # die if wirble unavailable
+
+describe Looksee::WirbleCompatibility do
+  describe "when looksee is loaded" do
+    #
+    # Run the given ruby string, and return the standard output.
+    #
+    def init_irb_with(code)
+      code = <<-EOS.demargin.gsub(/\n/, ';')
+        |#{code}
+        |#{stubbing_code}
+        |lp Object.new
+      EOS
+      irb = File.join Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'].sub(/ruby/, 'irb')
+      lib_dir = File.expand_path('lib')
+      # irb hangs when using readline without a tty
+      output = IO.popen("#{irb} -f --noreadline --noprompt --noverbose -I#{lib_dir} 2>&1", 'r+') do |io|
+        io.puts code
+        io.flush
+        io.close_write
+        io.read
+      end
+    end
+
+    def stubbing_code
+      <<-EOS.demargin
+        |C = Class.new
+        |
+        |Looksee.styles = Hash.new{'%s'}
+        |Looksee.styles[:public] = "\\e[1;32m%s\\e[0m"
+        |
+        |def Looksee.lookup_modules(object)
+        |  [C]
+        |end
+        |def Looksee.internal_public_instance_methods(mod)
+        |  [:a]
+        |end
+        |def Looksee.internal_protected_instance_methods(mod)
+        |  []
+        |end
+        |def Looksee.internal_private_instance_methods(mod)
+        |  []
+        |end
+      EOS
+    end
+
+    it "should work if wirble is not loaded" do
+      output = init_irb_with(<<-EOS.demargin)
+        |require 'irb'
+        |require 'looksee/shortcuts'
+        |require 'wirble'
+        |Wirble.init
+        |Wirble.colorize
+      EOS
+      output.should == <<-EOS.demargin
+        |C
+        |  \e[1;32ma\e[0m
+      EOS
+    end
+
+    it "should work if wirble is loaded, but not initialized" do
+      output = init_irb_with(<<-EOS.demargin)
+        |require 'irb'
+        |require 'wirble'
+        |require 'looksee/shortcuts'
+        |Wirble.init
+        |Wirble.colorize
+      EOS
+      output.should == <<-EOS.demargin
+        |C
+        |  \e[1;32ma\e[0m
+      EOS
+    end
+
+    it "should work if wirble is loaded and initialized, but colorizing is off" do
+      output = init_irb_with(<<-EOS.demargin)
+        |require 'irb'
+        |require 'wirble'
+        |Wirble.init
+        |require 'looksee/shortcuts'
+        |Wirble.colorize
+      EOS
+      output.should == <<-EOS.demargin
+        |C
+        |  \e[1;32ma\e[0m
+      EOS
+    end
+
+    it "should work if wirble is loaded, initialized, and colorizing is on" do
+      output = init_irb_with(<<-EOS.demargin)
+        |require 'irb'
+        |require 'wirble'
+        |Wirble.init
+        |Wirble.colorize
+        |require 'looksee/shortcuts'
+      EOS
+      output.should == <<-EOS.demargin
+        |C
+        |  \e[1;32ma\e[0m
+      EOS
+    end
+
+    it "should work if wirble colorizing is enabled twice" do
+      output = init_irb_with(<<-EOS.demargin)
+        |require 'irb'
+        |require 'looksee/shortcuts'
+        |require 'wirble'
+        |Wirble.init
+        |Wirble.colorize
+        |Wirble.colorize
+      EOS
+      output.should == <<-EOS.demargin
+        |C
+        |  \e[1;32ma\e[0m
+      EOS
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: looksee
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - George Ogata
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 -04:00
+date: 2009-08-01 00:00:00 +12:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,81 +55,6 @@ dependencies:
 description: |-
   Looksee lets you examine the method lookup path of objects in ways not
   possible in plain ruby.
-  
-  Pop this in your .irbrc :
-  
-      require 'looksee/shortcuts'
-  
-  This defines a method +lp+ ("lookup path") which lets you do:
-  
-      irb(main):001:0> lp []
-      => Array
-        &            concat      frozen?      push          taguri
-        *            count       hash         rassoc        taguri=
-        +            cycle       include?     reject        take
-        -            delete      index        reject!       take_while
-        <<           delete_at   indexes      replace       to_a
-        <=>          delete_if   indices      reverse       to_ary
-        ==           drop        insert       reverse!      to_s
-        []           drop_while  inspect      reverse_each  to_yaml
-        []=          each        join         rindex        transpose
-        assoc        each_index  last         select        uniq
-        at           empty?      length       shift         uniq!
-        choice       eql?        map          shuffle       unshift
-        clear        fetch       map!         shuffle!      values_at
-        collect      fill        nitems       size          yaml_initialize
-        collect!     find_index  pack         slice         zip
-        combination  first       permutation  slice!        |
-        compact      flatten     pop          sort
-        compact!     flatten!    product      sort!
-      Enumerable
-        all?        each_slice       first     min        reverse_each
-        any?        each_with_index  grep      min_by     select
-        collect     entries          group_by  minmax     sort
-        count       enum_cons        include?  minmax_by  sort_by
-        cycle       enum_slice       inject    none?      take
-        detect      enum_with_index  map       one?       take_while
-        drop        find             max       partition  to_a
-        drop_while  find_all         max_by    reduce     zip
-        each_cons   find_index       member?   reject
-      Object
-        taguri  taguri=  to_yaml  to_yaml_properties  to_yaml_style
-      Kernel
-        ==        hash                        object_id
-        ===       id                          private_methods
-        =~        inspect                     protected_methods
-        __id__    instance_eval               public_methods
-        __send__  instance_exec               respond_to?
-        class     instance_of?                send
-        clone     instance_variable_defined?  singleton_methods
-        display   instance_variable_get       taint
-        dup       instance_variable_set       tainted?
-        enum_for  instance_variables          tap
-        eql?      is_a?                       to_a
-        equal?    kind_of?                    to_enum
-        extend    method                      to_s
-        freeze    methods                     type
-        frozen?   nil?                        untaint
-  
-  It'll also color the methods according to whether they're public,
-  protected, private, or overridden.  So pretty.  You gotta try it.
-  
-  By default, it shows public and protected methods.  Add private ones
-  like so:
-  
-      lp [], :private => true
-      lp [], :private          # shortcut
-  
-  Or if you don't want protected:
-  
-      lp [], :protected => false
-  
-  There are variations too.  And you can configure things.  And you can
-  use it as a library without polluting the built-in classes.  See:
-  
-      $ ri Looksee
-  
-  Enjoy!
 email: 
 - george.ogata@gmail.com
 executables: []
@@ -151,11 +76,14 @@ files:
 - lib/looksee.rb
 - lib/looksee/shortcuts.rb
 - lib/looksee/version.rb
+- lib/looksee/wirble_compatibility.rb
+- looksee.gemspec
 - script/console
 - script/destroy
 - script/generate
 - spec/looksee_spec.rb
 - spec/spec_helper.rb
+- spec/wirble_compatibility_spec.rb
 - tasks/extconf.rake
 - tasks/extconf/looksee.rake
 has_rdoc: true
@@ -187,6 +115,6 @@ rubyforge_project: looksee
 rubygems_version: 1.3.4
 signing_key: 
 specification_version: 3
-summary: Looksee lets you examine the method lookup path of objects in ways not possible in plain ruby
+summary: Looksee lets you examine the method lookup path of objects in ways not possible in plain ruby.
 test_files: []