oggy-looksee 0.0.1 → 0.1.0

data/History.txt

@@ -1,3 +1,14 @@
+== 0.1.0 2009-08-20
+
+* Add methods undefined with Module#undef_method.  Blue by default.
+
+== 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/README.rdoc

@@ -65,7 +65,8 @@ This defines a method +lp+ ("lookup path") which lets you do:
       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.
+protected, private, undefined (using Module#undef_method), or
+overridden.  So pretty.  You gotta try it.
 
 By default, it shows public and protected methods.  Add private ones
 like so:

data/Rakefile

@@ -6,7 +6,7 @@ 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'

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);
 }
 
 /*
@@ -115,6 +115,23 @@ VALUE Looksee_internal_private_instance_methods(VALUE self, VALUE klass) {
   return internal_instance_methods(klass, NOEX_PRIVATE);
 }
 
+static int add_method_if_undefined(ID method_name, NODE *body, VALUE *names) {
+  /* Module#undef_method sets body->nd_body to NULL. */
+  if (body && !body->nd_body)
+    rb_ary_push(*names, ID2SYM(method_name));
+  return ST_CONTINUE;
+}
+
+/*
+ * Return the list of undefined instance methods (as Symbols) of the
+ * given internal class.
+ */
+VALUE Looksee_internal_undefined_instance_methods(VALUE self, VALUE klass) {
+  VALUE names = rb_ary_new();
+  st_foreach(RCLASS_M_TBL(klass), add_method_if_undefined, (st_data_t)&names);
+  return names;
+}
+
 void Init_looksee(void) {
   VALUE mLooksee = rb_define_module("Looksee");
   rb_define_singleton_method(mLooksee, "internal_superclass", Looksee_internal_superclass, 1);
@@ -123,4 +140,5 @@ void Init_looksee(void) {
   rb_define_singleton_method(mLooksee, "internal_public_instance_methods", Looksee_internal_public_instance_methods, 1);
   rb_define_singleton_method(mLooksee, "internal_protected_instance_methods", Looksee_internal_protected_instance_methods, 1);
   rb_define_singleton_method(mLooksee, "internal_private_instance_methods", Looksee_internal_private_instance_methods, 1);
+  rb_define_singleton_method(mLooksee, "internal_undefined_instance_methods", Looksee_internal_undefined_instance_methods, 1);
 }

data/lib/looksee.rb

@@ -32,8 +32,8 @@ require "looksee/version"
 #
 # +lp+ returns a LookupPath object, which has +inspect+ defined to
 # print things out pretty.  By default, it shows public, protected,
-# and overridden methods.  They're all colored, which makes showing
-# overridden methods not such a strange idea.
+# undefined, and overridden methods.  They're all colored, which makes
+# showing overridden methods not such a strange idea.
 #
 # Some examples of the other shortcuts:
 #
@@ -66,9 +66,11 @@ module Looksee
     # * +:public+ - include public methods
     # * +:protected+ - include protected methods
     # * +:private+ - include private methods
+    # * +:undefined+ - include undefined methods (see Module#undef_method)
     # * +:overridden+ - include methods overridden by subclasses
     #
-    # The default (if options is nil or omitted) is [:public].
+    # The default (if options is nil or omitted) is given by
+    # #default_lookup_path_options.
     #
     def lookup_path(object, *options)
       normalized_options = Looksee.default_lookup_path_options.dup
@@ -77,13 +79,14 @@ module Looksee
         normalized_options[option] = true
       end
       normalized_options.update(hash_options)
-      LookupPath.new(object, normalized_options)
+      LookupPath.for(object, normalized_options)
     end
 
     #
     # The default options passed to lookup_path.
     #
-    # Default: <tt>{:public => true, :protected => true, :overridden => true}</tt>
+    # Default: <tt>{:public => true, :protected => true, :undefined =>
+    # true, :overridden => true}</tt>
     #
     attr_accessor :default_lookup_path_options
 
@@ -104,6 +107,7 @@ module Looksee
     # * :public
     # * :protected
     # * :private
+    # * :undefined
     # * :overridden
     #
     # The values are format strings.  They should all contain a single
@@ -116,6 +120,7 @@ module Looksee
     #         :public     => "\e[1;32m%s\e[0m",
     #         :protected  => "\e[1;33m%s\e[0m",
     #         :private    => "\e[1;31m%s\e[0m",
+    #         :undefined  => "\e[1;34m%s\e[0m",
     #         :overridden => "\e[1;30m%s\e[0m",
     #       }
     #
@@ -136,19 +141,24 @@ module Looksee
     end
   end
 
-  self.default_lookup_path_options = {:public => true, :protected => true, :overridden => true}
+  self.default_lookup_path_options = {:public => true, :protected => true, :undefined => true, :overridden => true}
   self.default_width = 80
   self.styles = {
     :module     => "\e[1;37m%s\e[0m",
     :public     => "\e[1;32m%s\e[0m",
     :protected  => "\e[1;33m%s\e[0m",
     :private    => "\e[1;31m%s\e[0m",
+    :undefined  => "\e[1;34m%s\e[0m",
     :overridden => "\e[1;30m%s\e[0m",
   }
 
   class LookupPath
     attr_reader :entries
 
+    def initialize(entries)
+      @entries = entries
+    end
+
     #
     # Create a LookupPath for the given object.
     #
@@ -158,25 +168,41 @@ module Looksee
     #   :public
     #   :protected
     #   :private
+    #   :undefined
     #   :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 +215,40 @@ 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  ]
+        add_methods(Looksee.internal_undefined_instance_methods(@module).map{|sym| sym.to_s}, :undefined, seen) if options[:undefined]
+        @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.
       #
@@ -219,7 +264,7 @@ module Looksee
 
       #
       # Yield each method along with its visibility (:public,
-      # :private, :protected, or :overridden).
+      # :private, :protected, :undefined, or :overridden).
       #
       def each
         @methods.each do |name|
@@ -236,7 +281,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 +314,8 @@ module Looksee
       # sequences.
       #
       def columnize(strings, width)
+        return '' if strings.empty?
+
         num_columns = 1
         layout = [strings]
         loop do
@@ -330,3 +378,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.1.0'
 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.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["George Ogata"]
+  s.date = %q{2009-08-20}
+  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", "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"]
+  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.2"])
+      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.2"])
+      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.2"])
+    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
@@ -214,35 +171,108 @@ describe Looksee do
       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)
+        Looksee.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)
+        Looksee.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)
+        Looksee.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)
+        Looksee.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){}
+        Looksee.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)
+        Looksee.internal_undefined_instance_methods(C).should == []
+      end
+    end
   end
 end
 
 describe Looksee::LookupPath do
-  before do
-    Looksee.default_lookup_path_options = {}
-  end
-
   include TemporaryClasses
 
+  def stub_methods(mod, public, protected, private, undefined)
+    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)
+    Looksee.stubs(:internal_undefined_instance_methods).with(mod).returns(undefined)
+  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
@@ -253,13 +283,13 @@ describe Looksee::LookupPath do
         end
         @object = Object.new
         Looksee.stubs(:lookup_modules).with(@object).returns([C, M])
-        stub_methods(C, ['public1', 'public2'], ['protected1', 'protected2'], ['private1', 'private2'])
-        stub_methods(M, ['public1', 'public2'], ['protected1', 'protected2'], ['private1', 'private2'])
+        stub_methods(C, ['public1', 'public2'], ['protected1', 'protected2'], ['private1', 'private2'], ['undefined1', 'undefined2'])
+        stub_methods(M, ['public1', 'public2'], ['protected1', 'protected2'], ['private1', 'private2'], ['undefined1', 'undefined2'])
       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 +298,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 +308,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
@@ -287,9 +317,19 @@ describe Looksee::LookupPath do
         EOS
       end
 
+      it "should show modules and undefined instance methods when only undefined methods are requested" do
+        lookup_path = Looksee::LookupPath.for(@object, :undefined => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
+          |C
+          |  undefined1  undefined2
+          |M
+          |  undefined1  undefined2
+        EOS
+      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
@@ -299,9 +339,9 @@ 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
+        stub_methods(C.singleton_class, ['public1', 'public2'], [], [], [])
+        lookup_path = Looksee::LookupPath.for(C, :public => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |[C]
           |  public1  public2
         EOS
@@ -309,13 +349,23 @@ 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
+        stub_methods(C.singleton_class.singleton_class, ['public1', 'public2'], [], [], [])
+        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
@@ -325,6 +375,7 @@ describe Looksee::LookupPath do
           :public     => "{%s}",
           :protected  => "[%s]",
           :private    => "<%s>",
+          :undefined  => "~%s~",
           :overridden => "(%s)",
         }
         Looksee.stubs(:styles).returns(styles)
@@ -333,11 +384,11 @@ describe Looksee::LookupPath do
       it "should delimit each word with the configured delimiters" 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
+        stub_methods(C, ['public'], ['protected'], ['private'], ['undefined'])
+        lookup_path = Looksee::LookupPath.for(Object.new, :public => true, :protected => true, :private => true, :undefined => true, :overridden => true)
+        lookup_path.inspect.should == <<-EOS.demargin.chomp
           |\`C\'
-          |  <private>  [protected]  {public}
+          |  <private>  [protected]  {public}  ~undefined~
         EOS
       end
     end
@@ -346,9 +397,9 @@ describe Looksee::LookupPath do
       it "should wrap method lists at the configured number of columns, sorting vertically first, and aligning into a grid" 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
+        stub_methods(C, %w'aa b c dd ee f g hh i', [], [], [])
+        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
@@ -359,10 +410,10 @@ describe Looksee::LookupPath do
         temporary_class :A
         temporary_class :B
         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
+        stub_methods(A, ['a', 'long_long_long_long_name'], [], [], [])
+        stub_methods(B, ['long_long_long', 'short'], [], [], [])
+        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: oggy-looksee
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - George Ogata
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 -07:00
+date: 2009-08-20 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.1
+        version: 1.5.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -74,15 +74,19 @@ 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: false
 homepage: http://github.com/oggy/looksee
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -105,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: looksee
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Looksee lets you examine the method lookup path of objects in ways not possible in plain ruby.