looksee 3.1.0-universal-java-1.8 → 4.0.0-universal-java-1.8

data/spec/looksee/adapter_spec.rb

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

data/spec/looksee/editor_spec.rb

@@ -99,7 +99,7 @@ describe Looksee::Editor do
     end
 
     it "should raise NoSourceLocationError and not run the editor if no source location is available" do
-      Looksee.adapter.stub(source_location: nil)
+      UnboundMethod.any_instance.stub(source_location: nil)
       expect { editor.edit(object, :f) }.to raise_error(Looksee::NoSourceLocationError)
       editor_invocation.should be_nil
     end

data/spec/looksee/inspector_spec.rb

@@ -17,8 +17,8 @@ describe Looksee::Inspector do
 
     describe "output width" do
       before do
-        Looksee.adapter.public_methods[C] = ['aa', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg', 'hh', 'ii', 'jj']
-        Looksee.adapter.public_methods[M] = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg', 'hhh']
+        add_methods C, public: ['aa', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg', 'hh', 'ii', 'jj']
+        add_methods M, public: ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg', 'hhh']
         @lookup_path = Looksee::LookupPath.new(@object)
       end
 
@@ -67,78 +67,78 @@ describe Looksee::Inspector do
     end
 
     it "should not show any blank lines if a module has no methods" do
-      Looksee.adapter.public_methods[M] = [:public1, :public2]
+      add_methods M, public: [:pub1, :pub2]
       lookup_path = Looksee::LookupPath.new(@object)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |M
-        |  public1  public2
+        |  pub1  pub2
         |C
       EOS
     end
 
     it "should show singleton classes as class names in brackets" do
       Looksee.adapter.ancestors[C] = [C.singleton_class]
-      Looksee.adapter.public_methods[C.singleton_class] = [:public1, :public2]
+      add_methods C.singleton_class, public: [:pub1, :pub2]
       lookup_path = Looksee::LookupPath.new(C)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |[C]
-        |  public1  public2
+        |  pub1  pub2
       EOS
     end
 
     it "should handle singleton classes of singleton classes correctly" do
       Looksee.adapter.ancestors[C.singleton_class] = [C.singleton_class.singleton_class]
-      Looksee.adapter.public_methods[C.singleton_class.singleton_class] = [:public1, :public2]
+      add_methods C.singleton_class.singleton_class, public: [:pub1, :pub2]
       lookup_path = Looksee::LookupPath.new(C.singleton_class)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |[[C]]
-        |  public1  public2
+        |  pub1  pub2
       EOS
     end
 
     it "should only show methods of the selected visibilities" do
       temporary_class :E
-      Looksee.adapter.set_methods(E, [:public], [:protected], [:private], [:undefined])
+      add_methods(E, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
       Looksee.adapter.ancestors[@object] = [E]
       lookup_path = Looksee::LookupPath.new(@object)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:protected])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |E
-        |  protected
+        |  pro
       EOS
     end
 
     it "should show overridden methods if selected" do
-      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
-      Looksee.adapter.set_methods(M, [:public], [:protected], [:private], [:undefined])
+      add_methods(C, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
+      add_methods(M, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
       lookup_path = Looksee::LookupPath.new(@object)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :overridden])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |M
-        |  public
+        |  pub
         |C
-        |  public
+        |  pub
       EOS
     end
 
     it "should not show overridden methods if not selected" do
-      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
-      Looksee.adapter.set_methods(M, [:public], [:protected], [:private], [:undefined])
+      add_methods(C, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
+      add_methods(M, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
       lookup_path = Looksee::LookupPath.new(@object)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :nooverridden])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |M
         |C
-        |  public
+        |  pub
       EOS
     end
 
     it "should only show methods that match the given filters, if any are given" do
-      Looksee.adapter.public_methods[C] = [:ab, :ax, :ba, :xa]
-      Looksee.adapter.public_methods[M] = [:ab, :ax, :ba, :xa]
+      add_methods C, public: [:ab, :ax, :ba, :xa]
+      add_methods M, public: [:ab, :ax, :ba, :xa]
       lookup_path = Looksee::LookupPath.new(@object)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :overridden], :filters => [/^a/, 'b'])
       inspector.inspect.should == <<-EOS.demargin.chomp
@@ -167,12 +167,12 @@ describe Looksee::Inspector do
       temporary_class :C
       c = C.new
       Looksee.adapter.ancestors[c] = [C]
-      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
+      add_methods(C, public: [:pub], protected: [:pro], private: [:pri], undefined: [:und])
       lookup_path = Looksee::LookupPath.new(c)
       inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :protected, :private, :undefined, :overridden])
       inspector.inspect.should == <<-EOS.demargin.chomp
         |\`C\'
-        |  <private>  [protected]  {public}  ~undefined~
+        |  <pri>  [pro]  {pub}  ~und~
       EOS
     end
   end