looksee 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 043c93dbfb3a9b3265c16bad31a24a55d44347dc
-  data.tar.gz: 7bf0c2ddc5754750249f294558b745735cd6df5c
+  metadata.gz: 9d5b5cb3860af73f5d3800d9f580eecafa4c4f6f
+  data.tar.gz: eafb21b450e03a9a1620937aa646013aa3684516
 SHA512:
-  metadata.gz: 3c4b7518aa4038be29936338144dec78cd168d79ff0aafefa5f9a6b952ef17e493e3bdf1b651b756a1693adcd5b8d53ab6954cc3fe86439e3e4c680204bbf6b5
-  data.tar.gz: dade1e434a9b715cac40ffc689bfe1d5ba2da064a7f33bcad870b693c4dbc93772e769af422161edb0eb1713e8ad02f41b75b5b697e422bd8f98d39c68389c38
+  metadata.gz: 9be481e1b3359c05ec6be675284bf370dc9fecab2c9f42a6c6b81ecf454ed238b243111f48d5d17c1549afaf05cc06c44be4745bb0f64be31bd2de13526762c5
+  data.tar.gz: c146b1c1b04970ae648d561eea58ef80e9cc9b309c8740a2696592284d360ac6ec60a45f7aa342c92dd14a057b0365ba79488b65d3e0c810a6c2d96e9a7a1cb7

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 2.1.0 2014-03-05
+
+ * Add alternative syntax: Looksee[object, *args]. Useful for BasicObject
+   instances, and proxies which delegate #ls via method_missing.
+ * Fix display of origin classes (used when modules are prepended).
+
 == 2.0.0 2014-01-01
 
  * Support for MRI 2.1, JRuby 1.7, Rubinius 2.2.

data/README.markdown

@@ -115,19 +115,35 @@ Or filter the list by Regexp:
     Array
       to_a  to_ary  to_s  to_yaml
 
-And if you want to know more about any of those methods, Looksee can
+## Proxy objects
+
+Objects that delegate everything via `method_missing` to some other object can
+be tricky, because they will delegate `ls` itself. To view such objects, you can
+always do:
+
+    Looksee[object]
+
+This method inspects the object via interpreter extensions, so it works for the
+most Byzantine object. It will also work for `BasicObject` instances that don't
+have an `ls` method. `Object#ls` is simply a wrapper around `Looksee.[]`.
+
+## To the source!
+
+If you want to know more about any of those methods, Looksee can
 take you straight to the source in your editor:
 
-    > [].ls.edit :to_set
+    [].ls.edit :to_set
 
 By default, this uses `vi`; customize it like this:
 
     # %f = file, %l = line number
     Looksee.editor = "mate -l%l %f"
 
-See more in the quick reference:
+## Quick Reference
+
+We've got one:
 
-    irb> Looksee.help
+    Looksee.help
 
 Enjoy!
 

data/ext/mri/mri.c

@@ -62,25 +62,6 @@ VALUE Looksee_internal_class(VALUE self, VALUE object) {
   return CLASS_OF(object);
 }
 
-/*
- * Return the class or module that the given internal class
- * represents.
- *
- * If a class is given, this is the class.  If an iclass is given,
- * this is the module it represents in the lookup chain.
- */
-VALUE Looksee_internal_class_to_module(VALUE self, VALUE internal_class) {
-  if (!SPECIAL_CONST_P(internal_class)) {
-    switch (BUILTIN_TYPE(internal_class)) {
-    case T_ICLASS:
-      return RBASIC(internal_class)->klass;
-    case T_CLASS:
-      return internal_class;
-    }
-  }
-  rb_raise(rb_eArgError, "not an internal class: %s", RSTRING_PTR(rb_inspect(internal_class)));
-}
-
 #if RUBY_VERSION >= 192
 
 #  define VISIBILITY_TYPE rb_method_flag_t
@@ -208,6 +189,15 @@ VALUE Looksee_internal_undefined_instance_methods(VALUE self, VALUE klass) {
   return names;
 }
 
+/*
+ * Return true if the given object is an included class or origin class, false
+ * otherwise.
+ */
+VALUE Looksee_included_class_p(VALUE self, VALUE object) {
+  return !SPECIAL_CONST_P(object) && BUILTIN_TYPE(object) == T_ICLASS ?
+    Qtrue : Qfalse;
+}
+
 VALUE Looksee_singleton_class_p(VALUE self, VALUE object) {
   return BUILTIN_TYPE(object) == T_CLASS && FL_TEST(object, FL_SINGLETON) ? Qtrue : Qfalse;
 }
@@ -227,6 +217,12 @@ VALUE Looksee_module_name(VALUE self, VALUE module) {
   if (BUILTIN_TYPE(module) == T_CLASS || BUILTIN_TYPE(module) == T_MODULE) {
     VALUE name = rb_mod_name(module);
     return name == Qnil ? rb_str_new2("") : name;
+  } else if (BUILTIN_TYPE(module) == T_ICLASS) {
+    VALUE wrapped = RBASIC(module)->klass;
+    VALUE name = Looksee_module_name(self, wrapped);
+    if (BUILTIN_TYPE(wrapped) == T_CLASS)
+      name = rb_str_cat2(name, " (origin)");
+    return name;
   } else {
     rb_raise(rb_eTypeError, "expected module, got %s", rb_obj_classname(module));
   }
@@ -291,11 +287,11 @@ void Init_mri(void) {
   VALUE mMRI = rb_define_class_under(mAdapter, "MRI", mBase);
   rb_define_method(mMRI, "internal_superclass", Looksee_internal_superclass, 1);
   rb_define_method(mMRI, "internal_class", Looksee_internal_class, 1);
-  rb_define_method(mMRI, "internal_class_to_module", Looksee_internal_class_to_module, 1);
   rb_define_method(mMRI, "internal_public_instance_methods", Looksee_internal_public_instance_methods, 1);
   rb_define_method(mMRI, "internal_protected_instance_methods", Looksee_internal_protected_instance_methods, 1);
   rb_define_method(mMRI, "internal_private_instance_methods", Looksee_internal_private_instance_methods, 1);
   rb_define_method(mMRI, "internal_undefined_instance_methods", Looksee_internal_undefined_instance_methods, 1);
+  rb_define_method(mMRI, "included_class?", Looksee_included_class_p, 1);
   rb_define_method(mMRI, "singleton_class?", Looksee_singleton_class_p, 1);
   rb_define_method(mMRI, "singleton_instance", Looksee_singleton_instance, 1);
   rb_define_method(mMRI, "module_name", Looksee_module_name, 1);

data/lib/looksee/adapter/base.rb

@@ -9,7 +9,7 @@ module Looksee
         modules = []
         klass = internal_class(object)
         while klass
-          modules << internal_class_to_module(klass)
+          modules << klass
           klass = internal_superclass(klass)
         end
         modules
@@ -28,7 +28,7 @@ module Looksee
           object = singleton_instance(object)
         end
 
-        if object.is_a?(Module)
+        if included_class?(mod) || object.is_a?(Module)
           description = module_name(object)
           if description.empty?
             description = "unnamed #{object.is_a?(Class) ? 'Class' : 'Module'}"
@@ -52,7 +52,7 @@ module Looksee
         raise NotImplementedError, "abstract"
       end
 
-      def internal_class_to_module(internal_class)
+      def included_class?(object)
         raise NotImplementedError, "abstract"
       end
 

data/lib/looksee/adapter/rubinius.rb

@@ -8,27 +8,23 @@ module Looksee
         klass.direct_superclass
       end
 
-      def internal_class_to_module(internal_class)
-        if internal_class.is_a?(::Rubinius::IncludedModule)
-          internal_class.module
-        else
-          internal_class
-        end
-      end
-
       def internal_public_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
         mod.method_table.public_names
       end
 
       def internal_protected_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
         mod.method_table.protected_names
       end
 
       def internal_private_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
         mod.method_table.private_names
       end
 
       def internal_undefined_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
         names = []
         mod.method_table.entries.each do |(name, method, visibility)|
           names << name if visibility.equal?(:undef)
@@ -36,6 +32,10 @@ module Looksee
         names
       end
 
+      def included_class?(object)
+        object.is_a?(::Rubinius::IncludedModule)
+      end
+
       def singleton_class?(object)
         object.is_a?(Class) && !!::Rubinius::Type.singleton_class_object(object)
       end
@@ -50,7 +50,13 @@ module Looksee
         mod.is_a?(Module) or
           raise TypeError, "expected module, got #{mod.class}"
 
-        if ::Rubinius::Type.respond_to?(:module_name)
+        if ::Rubinius::IncludedModule === mod
+          if Class === mod.module
+            "#{module_name(mod.module)} (origin)"
+          else
+            module_name(mod.module)
+          end
+        elsif ::Rubinius::Type.respond_to?(:module_name)
           ::Rubinius::Type.module_name(mod) || ''
         else
           mod.__name__

data/lib/looksee/clean.rb

@@ -90,6 +90,48 @@ module Looksee
     #
     attr_accessor :ruby_engine
 
+    #
+    # Return a Looksee::Inspector for the given +object+.
+    #
+    # +args+ is an optional list of specifiers.
+    #
+    #   * +:public+ - include public methods
+    #   * +:protected+ - include public methods
+    #   * +:private+ - include public methods
+    #   * +:undefined+ - include public methods (see Module#undef_method)
+    #   * +:overridden+ - include public methods
+    #   * +:nopublic+ - include public methods
+    #   * +:noprotected+ - include public methods
+    #   * +:noprivate+ - include public methods
+    #   * +:noundefined+ - include public methods (see Module#undef_method)
+    #   * +:nooverridden+ - include public methods
+    #   * a string - only include methods containing this string (may
+    #     be used multiple times)
+    #   * a regexp - only include methods matching this regexp (may
+    #     be used multiple times)
+    #
+    # The default (if options is nil or omitted) is given by
+    # #default_lookup_path_options.
+    #
+    def [](object, *args)
+      options = {:visibilities => Set[], :filters => Set[]}
+      (Looksee.default_specifiers + args).each do |arg|
+        case arg
+        when String, Regexp
+          options[:filters] << arg
+        when :public, :protected, :private, :undefined, :overridden
+          options[:visibilities].add(arg)
+        when :nopublic, :noprotected, :noprivate, :noundefined, :nooverridden
+          visibility = arg.to_s.sub(/\Ano/, '').to_sym
+          options[:visibilities].delete(visibility)
+        else
+          raise ArgumentError, "invalid specifier: #{arg.inspect}"
+        end
+      end
+      lookup_path = LookupPath.new(object)
+      Inspector.new(lookup_path, options)
+    end
+
     #
     # Show a quick reference.
     #

data/lib/looksee/core_ext.rb

@@ -1,45 +1,10 @@
 module Looksee
   module ObjectMixin
     #
-    # Return a Looksee::Inspector for this object.
-    #
-    # +args+ is an optional list of specifiers.
-    #
-    #   * +:public+ - include public methods
-    #   * +:protected+ - include public methods
-    #   * +:private+ - include public methods
-    #   * +:undefined+ - include public methods (see Module#undef_method)
-    #   * +:overridden+ - include public methods
-    #   * +:nopublic+ - include public methods
-    #   * +:noprotected+ - include public methods
-    #   * +:noprivate+ - include public methods
-    #   * +:noundefined+ - include public methods (see Module#undef_method)
-    #   * +:nooverridden+ - include public methods
-    #   * a string - only include methods containing this string (may
-    #     be used multiple times)
-    #   * a regexp - only include methods matching this regexp (may
-    #     be used multiple times)
-    #
-    # The default (if options is nil or omitted) is given by
-    # #default_lookup_path_options.
+    # Shortcut for Looksee[self, *args].
     #
     def ls(*args)
-      options = {:visibilities => Set[], :filters => Set[]}
-      (Looksee.default_specifiers + args).each do |arg|
-        case arg
-        when String, Regexp
-          options[:filters] << arg
-        when :public, :protected, :private, :undefined, :overridden
-          options[:visibilities].add(arg)
-        when :nopublic, :noprotected, :noprivate, :noundefined, :nooverridden
-          visibility = arg.to_s.sub(/\Ano/, '').to_sym
-          options[:visibilities].delete(visibility)
-        else
-          raise ArgumentError, "invalid specifier: #{arg.inspect}"
-        end
-      end
-      lookup_path = LookupPath.new(self)
-      Inspector.new(lookup_path, options)
+      Looksee[self, *args]
     end
 
     def self.rename(name)  # :nodoc:

data/lib/looksee/help.rb

@@ -4,7 +4,7 @@ module Looksee
       <<-EOS.gsub(/^ *\|/, '')
         |== Looksee Quick Reference
         |
-        |  object.ls(*specifiers)
+        |  object.ls(*specifiers)  or  Looksee[object, *specifiers]
         |    Print the methods of \`object\'.
         |
         |    Available specifiers:

data/lib/looksee/version.rb

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

data/spec/{adapter_spec.rb → looksee/adapter_spec.rb}

@@ -14,8 +14,9 @@ describe "Looksee.adapter" do
     # of singleton classes, since they have no name.
     #
     def filtered_lookup_modules(object)
-      result = @adapter.lookup_modules(object)
-      result.select{ |mod| deterministic_module?(mod) }
+      result = @adapter.lookup_modules(object).
+        map { |mod| @adapter.describe_module(mod) }.
+        select{ |description| deterministic_module?(description) }
     end
 
     #
@@ -25,7 +26,7 @@ describe "Looksee.adapter" do
     # This excludes ruby version dependent modules, and modules tossed
     # into the hierarchy by testing frameworks.
     #
-    def deterministic_module?(mod)
+    def deterministic_module?(description)
       junk_patterns = [
         # pollution from testing libraries
         'Mocha', 'Spec',
@@ -38,25 +39,10 @@ describe "Looksee.adapter" do
         # something pulls this in under ruby 1.9
         'PP',
         # our own pollution,
-        'Looksee::Object',
+        'Looksee::ObjectMixin',
       ]
-      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
+      pattern = /\b(#{junk_patterns.join('|')})\b/
+      description !~ pattern
     end
 
     it "should contain an entry for each module in the object's lookup path" do
@@ -67,23 +53,26 @@ describe "Looksee.adapter" do
         include Mod1
         include Mod2
       end
-      filtered_lookup_modules(Derived.new) == [Derived, Mod2, Mod1, Base, Object, Kernel]
+      filtered_lookup_modules(Derived.new) ==
+        ['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]
+      filtered_lookup_modules(object).should ==
+        ['[Object instance]', '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]
+      filtered_lookup_modules(C).should ==
+        ['[C]', '[Object]', 'Class', 'Module', 'Object', 'Kernel']
     end
 
     it "should work for immediate objects" do
-      filtered_lookup_modules(1).first.should == Fixnum
+      filtered_lookup_modules(1).first.should == 'Fixnum'
     end
   end
 
@@ -118,13 +107,27 @@ describe "Looksee.adapter" do
         @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
         add_methods C, visibility => [:removed]
         C.send(:undef_method, :removed)
         @adapter.send(target_method, C).to_set.should == Set[]
       end
+
+      if RUBY_VERSION >= '2'
+        it "should return methods only for origin classes" do
+          temporary_class :C
+          add_methods C, visibility => :one
+          temporary_module :M
+          add_methods M, visibility => :one
+          C.send(:prepend, M)
+          @adapter.send(target_method, C).should be_empty
+
+          origin = @adapter.lookup_modules(C.new).
+            find { |mod| @adapter.describe_module(mod) == 'C (origin)' }
+          @adapter.send(target_method, origin).should_not be_empty
+        end
+      end
     end
 
     def self.it_should_not_list_methods_with_visibility(visibility1, visibility2)
@@ -200,6 +203,24 @@ describe "Looksee.adapter" do
         struct_singleton_class = (class << Struct; self; end)
         @adapter.internal_undefined_instance_methods(struct_singleton_class).should == []
       end
+
+      if RUBY_VERSION >= '2'
+        it "should return an empty list for non-origin classes" do
+          temporary_class :C
+          C.send(:define_method, :f){}
+          C.send(:undef_method, :f)
+          temporary_module :M
+          M.send(:define_method, :f){}
+          M.send(:undef_method, :f)
+          C.send(:prepend, M)
+
+          @adapter.internal_undefined_instance_methods(C).should be_empty
+
+          origin = @adapter.lookup_modules(C.new).
+            find { |mod| @adapter.describe_module(mod) == 'C (origin)' }
+          @adapter.internal_undefined_instance_methods(origin).should_not be_empty
+        end
+      end
     end
   end
 

data/spec/{core_ext_spec.rb → looksee/clean_spec.rb}

@@ -1,40 +1,40 @@
 require 'spec_helper'
 
-describe Looksee::ObjectMixin do
-  describe "#ls" do
+describe Looksee do
+  describe ".[]" do
     before do
       @object = Object.new
       Looksee.stub(:default_specifiers).and_return([:public, :overridden])
     end
 
     it "should return an Inspector for the object's lookup path" do
-      result = @object.ls
+      result = Looksee[@object]
       result.should be_a(Looksee::Inspector)
       result.lookup_path.object.should.equal?(@object)
     end
 
     it "should use Looksee.default_specifiers if no args are given" do
-      @object.ls.visibilities.should == Set[:public, :overridden]
+      Looksee[@object].visibilities.should == Set[:public, :overridden]
     end
 
     it "should set visibilities from the given symbols" do
-      inspector = @object.ls(:private)
+      inspector = Looksee[@object, :private]
       inspector.visibilities.should == Set[:public, :overridden, :private]
     end
 
     it "should unset visibilities from the given 'no' symbols" do
-      inspector = @object.ls(:nooverridden)
+      inspector = Looksee[@object, :nooverridden]
       inspector.visibilities.should == Set[:public]
     end
 
     it "should set filters from the given strings and regexp" do
-      inspector = @object.ls('aa', /bb/)
+      inspector = Looksee[@object, 'aa', /bb/]
       inspector.filters.should == Set['aa', /bb/]
     end
 
     it "should raise an ArgumentError if an invalid argument is given" do
       lambda do
-        @object.ls(Object.new)
+        Looksee[@object, Object.new]
       end.should raise_error(ArgumentError)
     end
   end

data/spec/looksee/core_ext_spec.rb

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

data/spec/support/test_adapter.rb

@@ -19,6 +19,10 @@ class TestAdapter < Looksee::Adapter::Base
     undefined_methods[mod]
   end
 
+  def included_class?(object)
+    NATIVE_ADAPTER.included_class?(object)
+  end
+
   def singleton_class?(object)
     NATIVE_ADAPTER.singleton_class?(object)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: looksee
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - George Ogata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-01 00:00:00.000000000 Z
+date: 2014-03-05 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -64,20 +64,21 @@ files:
 - lib/looksee/help.rb
 - lib/looksee/inspector.rb
 - lib/looksee/lookup_path.rb
-- lib/looksee/shortcuts.rb
+- lib/looksee/rbx.bundle
 - lib/looksee/version.rb
 - lib/looksee/wirble_compatibility.rb
-- spec/adapter_spec.rb
-- spec/columnizer_spec.rb
-- spec/core_ext_spec.rb
-- spec/editor_spec.rb
-- spec/inspector_spec.rb
-- spec/lookup_path_spec.rb
+- spec/looksee/adapter_spec.rb
+- spec/looksee/clean_spec.rb
+- spec/looksee/columnizer_spec.rb
+- spec/looksee/core_ext_spec.rb
+- spec/looksee/editor_spec.rb
+- spec/looksee/inspector_spec.rb
+- spec/looksee/lookup_path_spec.rb
+- spec/looksee/wirble_compatibility_spec.rb
 - spec/spec_helper.rb
 - spec/support/core_ext.rb
 - spec/support/temporary_classes.rb
 - spec/support/test_adapter.rb
-- spec/wirble_compatibility_spec.rb
 homepage: http://github.com/oggy/looksee
 licenses:
 - MIT
@@ -98,19 +99,20 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 3
 summary: Supercharged method introspection in IRB.
 test_files:
-- spec/adapter_spec.rb
-- spec/columnizer_spec.rb
-- spec/core_ext_spec.rb
-- spec/editor_spec.rb
-- spec/inspector_spec.rb
-- spec/lookup_path_spec.rb
+- spec/looksee/adapter_spec.rb
+- spec/looksee/clean_spec.rb
+- spec/looksee/columnizer_spec.rb
+- spec/looksee/core_ext_spec.rb
+- spec/looksee/editor_spec.rb
+- spec/looksee/inspector_spec.rb
+- spec/looksee/lookup_path_spec.rb
+- spec/looksee/wirble_compatibility_spec.rb
 - spec/spec_helper.rb
 - spec/support/core_ext.rb
 - spec/support/temporary_classes.rb
 - spec/support/test_adapter.rb
-- spec/wirble_compatibility_spec.rb

data/lib/looksee/shortcuts.rb

@@ -1,3 +0,0 @@
-require 'looksee'
-
-warn "'looksee/shortcuts' is deprecated; please require 'looksee' instead."