reflexive 0.0.6 → 0.1.0

data/spec/integration_spec_fixture.rb

@@ -0,0 +1,87 @@
+require "ostruct"
+
+module IntegrationSpecFixture
+  module TestBaseModule
+  end
+
+  module TestModule
+    include TestBaseModule
+    def module_meth
+    end
+
+    def self.module_class_meth
+    end
+  end
+
+  class TestBaseClass
+    def inherited_meth
+    end
+
+    def self.inherited_class_meth
+    end
+
+    def self.another_inherited_class_meth
+    end
+  end
+
+  class TestClass < TestBaseClass
+    include TestModule
+
+    another_inherited_class_meth
+    
+    def self.class_meth
+      inherited_class_meth
+    end
+    
+    def public_meth
+      inherited_meth
+    end
+
+    class_eval do
+    end
+
+    protected
+    def protected_meth
+      local_var = 42
+      another_local_var = 42 + local_var
+      not_defined_meth
+    end
+
+    private
+    def private_meth
+    end
+
+    class NestedClass
+      def meth
+      end
+    end
+  end
+
+  module HeuristicLookupBaseModule
+  end
+
+  class HeuristicLookupIncludingClass1
+    include HeuristicLookupBaseModule
+    def meth
+    end
+  end
+
+  class HeuristicLookupIncludingClass2
+    include HeuristicLookupBaseModule
+    def meth
+    end
+  end
+
+  class HeuristicLookupBaseClass
+  end
+
+  class HeuristicLookupInheritingClass1 < HeuristicLookupBaseClass
+    def meth
+    end
+  end
+
+  class HeuristicLookupInheritingClass2 < HeuristicLookupBaseClass 
+    def meth
+    end
+  end
+end

data/spec/method_lookup_spec.rb

@@ -0,0 +1,348 @@
+require "reflexive/method_lookup"
+
+class TestBaseClass
+  def self.inherited_class_meth
+  end
+
+  def inherited_instance_meth
+  end
+end
+
+class TestClass < TestBaseClass
+  def initialize
+  end
+  
+  def self.class_meth
+  end
+
+  def instance_meth
+  end
+end
+
+module TestBaseModule
+  def inherited_module_meth
+  end
+end
+
+module TestModule
+  include TestBaseModule
+  
+  def self.class_module_meth
+  end
+
+  def instance_module_meth
+  end
+end
+
+class TestCoreMethodsCallingClass
+  #  # Module is class
+  #  # Module class
+  #  Module.new
+  #  Module.nesting
+  #  Module.constants
+  #
+  #  # Module instance
+  #  class_eval do
+  #
+  #  end
+  #  # many more...
+  #
+  #  # Class class
+  #  Class.inherited
+  #  Class.new
+  #
+  #  # Class instance
+  #  allocate
+  #  new
+  #  superclass
+  #
+  #  # Object instance
+  #  Object.new # single
+  #
+  #  # Object instance
+  #  clone
+  #  dup
+  #  freeze
+  #
+  #  # Kernel is module
+  #  # Kernel instance
+  #  Array
+  #  caller
+  #  # many more...
+end
+
+describe Reflexive::MethodLookup do
+  def ml(*args)
+    Reflexive::MethodLookup.new(*args)
+  end
+
+  def lookup_definitions(klass, level, name)
+    Reflexive::MethodLookup.new(klass: klass, level: level, name: name).definitions
+  end
+
+  def lookup_documentations(klass, level, name)
+    Reflexive::MethodLookup.new(klass: klass, level: level, name: name).documentations
+  end
+
+  it "requires :klass, :level, :name as constructor arguments" do
+    proc { ml }.should raise_error(ArgumentError)
+    proc { ml(klass: TestClass) }.should raise_error(ArgumentError)
+    proc { ml(level: :instance) }.should raise_error(ArgumentError)
+    proc { ml(name: :meth) }.should raise_error(ArgumentError)
+    proc { ml(klass: TestClass, level: :class) }.should raise_error(ArgumentError)
+    proc { ml(klass: TestClass, level: :class, name: "meth") }.should_not raise_error
+  end
+
+  it "finds defined inherited instance methods for class" do
+    lookup_definitions(TestClass, :instance, :inherited_instance_meth).should ==
+            [[TestClass, :instance, :inherited_instance_meth]]
+  end
+
+  it "handles level and module names passed as strings normalizing them to symbols" do
+    lookup_definitions(TestClass, "instance", "inherited_instance_meth").should ==
+            [[TestClass, :instance, :inherited_instance_meth]]
+  end
+
+  it "finds defined inherited instance methods for module" do
+    lookup_definitions(TestModule, :instance, :inherited_module_meth).should ==
+            [[TestModule, :instance, :inherited_module_meth]]
+  end
+
+  it "finds defined owned instance methods for class" do
+    lookup_definitions(TestClass, :instance, :instance_meth).should ==
+            [[TestClass, :instance, :instance_meth]]
+  end
+
+  it "finds defined owned instance methods for module" do
+    lookup_definitions(TestModule, :instance, :instance_module_meth).should ==
+            [[TestModule, :instance, :instance_module_meth]]
+  end
+
+  it "finds defined inherited class methods" do
+    lookup_definitions(TestClass, :class, :inherited_class_meth).should ==
+            [[TestClass, :class, :inherited_class_meth]]
+  end
+
+  it "finds defined owned class methods for class" do
+    lookup_definitions(TestClass, :class, :class_meth).should ==
+            [[TestClass, :class, :class_meth]]
+  end
+
+  it "finds defined owned class methods for module" do
+    lookup_definitions(TestModule, :class, :class_module_meth).should ==
+            [[TestModule, :class, :class_module_meth]]
+  end
+
+  it "redirects class new method to instance initialize for classes" do
+    lookup_definitions(TestClass, :class, :new).should ==
+            [[TestClass, :instance, :initialize]]
+  end
+
+  describe "lookup of core native methods" do
+    it "for Kernel always redirects to instance methods" do
+      lookup_documentations(TestClass, :class, :require).should ==
+              [[Kernel, :instance, :require]]
+
+      lookup_documentations(TestClass, :instance, :require).should ==
+              [[Kernel, :instance, :require]]
+    end
+
+    it "for Module redirects to instance methods mostly" do
+      lookup_documentations(TestClass, :class, :class_eval).should ==
+              [[Module, :instance, :class_eval]]
+
+      lookup_documentations(Module, :class, :nesting).should ==
+              [[Module, :class, :nesting]]
+
+#      lookup_documentations(TestClass, :instance, :require).should ==
+#              [[Kernel, :instance, :require]]
+    end
+
+    it "for Class redirects to instance methods mostly" do
+      lookup_documentations(TestClass, :class, :superclass).should ==
+              [[Class, :instance, :superclass]]
+
+
+#      lookup_documentations(TestClass, :instance, :require).should ==
+#              [[Kernel, :instance, :require]]
+    end
+
+    class InheritedFromDir < Dir
+    end
+
+    it "doesn't handle normal library classes in a specific way" do
+      lookup_documentations(File, :class, :expand_path).should ==
+              [[File, :class, :expand_path]]
+      lookup_documentations(Dir, :instance, :path).should ==
+              [[Dir, :instance, :path]]
+      lookup_documentations(InheritedFromDir, :instance, :path).should ==
+              [[Dir, :instance, :path]]
+      lookup_documentations(InheritedFromDir, :class, :entries).should ==
+              [[Dir, :class, :entries]]
+    end
+  end
+
+  describe "heuristic lookup" do
+
+    describe "for just included module" do
+      module JustIncludedModule
+        def module_instance_meth
+          instance_meth
+        end
+      end
+
+      class IncludesJustIncludedModule
+        include JustIncludedModule
+
+        def instance_meth
+          42
+        end
+      end
+
+      class IncludesJustIncludedModuleAnother
+        include JustIncludedModule
+
+        def instance_meth
+          43
+        end
+      end
+
+      class IncludesJustIncludedModuleYetAnother
+        include JustIncludedModule
+      end
+
+      it "should setup sane fixture" do
+        IncludesJustIncludedModule.new.module_instance_meth.should == 42
+        IncludesJustIncludedModuleAnother.new.module_instance_meth.should == 43
+      end
+
+      it "finds instance_meth" do
+        lookup_definitions(JustIncludedModule, :instance, :instance_meth).should =~
+                [[IncludesJustIncludedModule, :instance, :instance_meth],
+                 [IncludesJustIncludedModuleAnother, :instance, :instance_meth]]
+      end
+    end
+
+    describe "for module included in singleton class" do
+      module JustIncludedInSingletonModule
+        def module_class_meth
+          class_meth
+        end
+      end
+
+      class IncludesJustIncludedInSingletonModule
+        extend JustIncludedInSingletonModule
+
+        def self.class_meth
+          42
+        end
+      end
+
+      it "should setup sane fixture" do
+        IncludesJustIncludedInSingletonModule.module_class_meth.should == 42
+      end
+
+      it "finds class_meth" do
+        lookup_definitions(JustIncludedInSingletonModule, :instance, :class_meth).should ==
+                [[IncludesJustIncludedInSingletonModule, :class, :class_meth]]
+      end
+    end
+
+    describe "for module included in module included in class in turn" do
+      module IncludedInModuleIncludedInClass
+        def module_instance_meth
+          class_instance_meth
+        end
+      end
+
+      module IncludesIncludedInModuleIncludedInClass
+        include IncludedInModuleIncludedInClass
+      end
+
+      class IncludesIncludesIncludedInModuleIncludedInClass
+        include IncludesIncludedInModuleIncludedInClass
+        def class_instance_meth
+          42
+        end
+      end
+
+      it "should setup sane fixture" do
+        IncludesIncludesIncludedInModuleIncludedInClass.new.module_instance_meth.should == 42
+      end
+
+      it "finds class_instance_meth" do
+        lookup_definitions(IncludedInModuleIncludedInClass, :instance, :class_instance_meth).should ==
+                [[IncludesIncludesIncludedInModuleIncludedInClass, :instance, :class_instance_meth]]
+      end
+    end
+
+    describe "for base class instance methods" do
+      class HeuristicLookupBaseClassInstanceMethods
+        def base_class_instance_meth
+          inherited_class_instance_meth
+        end
+      end
+
+      class HeuristicLookupInheritedClassInstanceMethods < HeuristicLookupBaseClassInstanceMethods
+        def inherited_class_instance_meth
+          42
+        end
+      end
+
+      class HeuristicLookupInheritedClassInstanceMethodsAnother < HeuristicLookupBaseClassInstanceMethods
+        def inherited_class_instance_meth
+          43
+        end
+      end
+
+      it "should setup sane fixture" do
+        HeuristicLookupInheritedClassInstanceMethods.new.base_class_instance_meth.should == 42
+      end
+
+      it "finds inherited_class_instance_meth" do
+        lookup_definitions(HeuristicLookupBaseClassInstanceMethods, :instance, :inherited_class_instance_meth).should =~
+                [[HeuristicLookupInheritedClassInstanceMethods, :instance, :inherited_class_instance_meth],
+                 [HeuristicLookupInheritedClassInstanceMethodsAnother, :instance, :inherited_class_instance_meth]]
+      end
+    end
+
+    describe "for base class class methods" do
+      class HeuristicLookupBaseClassClassMethods
+        def self.base_class_class_meth
+          inherited_class_class_meth
+        end
+      end
+
+      class HeuristicLookupInheritedClassClassMethods < HeuristicLookupBaseClassClassMethods
+        def self.inherited_class_class_meth
+          42
+        end
+      end
+
+      it "should setup sane fixture" do
+        HeuristicLookupInheritedClassClassMethods.base_class_class_meth.should == 42
+      end
+
+      it "finds inherited_class_class_meth" do
+        lookup_definitions(HeuristicLookupBaseClassClassMethods, :class, :inherited_class_class_meth).should ==
+                [[HeuristicLookupInheritedClassClassMethods, :class, :inherited_class_class_meth]]
+      end
+    end
+
+    describe "last resort lookup" do
+      module LastResortTestModule
+      end
+
+      class LastResortTestClass
+        def some_really_uniq_instance_method
+        end
+      end
+
+      it "finds some_really_uniq_instance_method" do
+        lookup_definitions(LastResortTestModule, :instance, :some_really_uniq_instance_method).should ==
+                [[LastResortTestClass, :instance, :some_really_uniq_instance_method]]
+      end
+    end
+  end
+end
+

data/spec/methods_spec.rb

@@ -14,26 +14,243 @@ Rspec::Matchers.define :generate_methods do |expected|
   end
 end
 
+describe "Ruby reflection capabilities" do
+  describe "for Modules" do
+    describe "#singleton_class" do
+      specify ".public_instance_methods(false) returns empty list for empty module" do
+        Module.new.singleton_class.
+                reflexive_public_instance_methods(false).should == []
+      end
+
+      specify ".protected_instance_methods(false) returns empty list for empty module" do
+        Module.new.singleton_class.
+                reflexive_protected_instance_methods(false).should == []
+      end
+
+      specify ".private_instance_methods(false) returns empty list for empty module" do
+        Module.new.singleton_class.
+                reflexive_private_instance_methods(false).should == []
+      end
+
+      specify ".public_instance_methods(false) returns public methods" do
+        Module.new { def self.m; end }.singleton_class.
+                reflexive_public_instance_methods(false).should == [:m]
+      end
+
+      specify ".protected_instance_methods(false) returns protected methods" do
+        Module.new { class << self; protected; def m; end end }.singleton_class.
+                reflexive_protected_instance_methods(false).should == [:m]
+      end
+
+      specify ".private_instance_methods(false) returns private methods" do
+        Module.new { class << self; private; def m; end end }.singleton_class.
+                reflexive_private_instance_methods(false).should == [:m]
+      end
+    end
+
+    specify ".public_instance_methods(false) returns empty list for empty module" do
+      Module.new.
+              reflexive_public_instance_methods(false).should == []
+    end
+
+    specify ".protected_instance_methods(false) returns empty list for empty module" do
+      Module.new.
+              reflexive_protected_instance_methods(false).should == []
+    end
+
+    specify ".private_instance_methods(false) returns empty list for empty module" do
+      Module.new.
+              reflexive_private_instance_methods(false).should == []
+    end
+
+    specify ".public_instance_methods(false) returns public methods" do
+      Module.new { def m; end }.
+              reflexive_public_instance_methods(false).should == [:m]
+    end
+
+    specify ".protected_instance_methods(false) returns protected methods" do
+      Module.new { protected; def m; end }.
+              reflexive_protected_instance_methods(false).should == [:m]
+    end
+
+    specify ".private_instance_methods(false) returns private methods" do
+      Module.new { private; def m; end }.
+              reflexive_private_instance_methods(false).should == [:m]
+    end
+  end
+
+  describe "for Classes" do
+    class ::RubyReflectionCapabilitiesEmptyClass
+    end
+
+    class ::RubyReflectionCapabilitiesSingletonMethodsClass
+      class << self
+        def publ
+        end
+        protected
+        def prot
+        end
+        private
+        def priv
+        end
+      end
+    end
+
+    class ::RubyReflectionCapabilitiesInstanceMethodsClass
+      def publ
+      end
+      protected
+      def prot
+      end
+      private
+      def priv
+      end
+    end
+
+    describe "#singleton_class" do
+      specify ".public_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.singleton_class.
+                reflexive_public_instance_methods(false).should == []
+      end
+
+      specify ".protected_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.singleton_class.
+                reflexive_protected_instance_methods(false).should == []
+      end
+
+      specify ".private_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.singleton_class.
+                reflexive_private_instance_methods(false).should == []
+      end
+
+      specify ".public_instance_methods(false) returns public methods" do
+        RubyReflectionCapabilitiesSingletonMethodsClass.singleton_class.
+                reflexive_public_instance_methods(false).should == [:publ]
+      end
+
+      specify ".protected_instance_methods(false) returns protected methods" do
+        RubyReflectionCapabilitiesSingletonMethodsClass.singleton_class.
+                reflexive_protected_instance_methods(false).should == [:prot]
+      end
+
+      specify ".private_instance_methods(false) returns private methods" do
+        RubyReflectionCapabilitiesSingletonMethodsClass.singleton_class.
+                reflexive_private_instance_methods(false).should == [:priv]
+      end
+    end
+
+    describe "#" do
+      specify ".public_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.
+                reflexive_public_instance_methods(false).should == []
+      end
+
+      specify ".protected_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.
+                reflexive_protected_instance_methods(false).should == []
+      end
+
+      specify ".private_instance_methods(false) returns empty list for empty class" do
+        RubyReflectionCapabilitiesEmptyClass.
+                reflexive_private_instance_methods(false).should == []
+      end
+
+     specify ".public_instance_methods(false) returns public methods" do
+        RubyReflectionCapabilitiesInstanceMethodsClass.
+                reflexive_public_instance_methods(false).should == [:publ]
+      end
+
+      specify ".protected_instance_methods(false) returns protected methods" do
+        RubyReflectionCapabilitiesInstanceMethodsClass.
+                reflexive_protected_instance_methods(false).should == [:prot]
+      end
+
+      specify ".private_instance_methods(false) returns private methods" do
+        RubyReflectionCapabilitiesInstanceMethodsClass.
+                reflexive_private_instance_methods(false).should == [:priv]
+      end
+    end
+  end
+end
+
 describe Reflexive::Methods do
+  describe "#trite_singleton_ancestors" do
+    it "returns some common trite objects" do
+      Reflexive::Methods.new(nil).
+              send(:trite_singleton_ancestors).
+              should(include(Class, Module, Object, BasicObject, Kernel))
+    end
+  end
+
+  describe "#trite_ancestors" do
+    it "returns some common trite objects" do
+      Reflexive::Methods.new(nil).
+              send(:trite_ancestors).
+              should(include(Object, Kernel, BasicObject))
+    end
+  end
+
+  describe "#collect_instance_methods" do
+    class ::CollectInstanceMethodsC
+      def public_instance_meth
+      end
+      protected
+      def protected_instance_meth
+      end
+      private
+      def private_instance_meth
+      end
+    end
+    
+    it "collects own (defined in class) instance methods for class" do
+      Reflexive::Methods.new(nil).
+              send(:collect_instance_methods, ::CollectInstanceMethodsC).
+              should == { :public => [ :public_instance_meth ],
+                          :protected => [ :protected_instance_meth ],
+                          :private => [ :private_instance_meth ] }
+    end
+
+    module ::CollectInstanceMethodsEmptyM
+    end
+
+    it "reports empty own instance methods for empty module" do
+      Reflexive::Methods.new(nil).
+              send(:collect_instance_methods, ::CollectInstanceMethodsEmptyM).
+              should == nil
+    end
+
+    it "reports empty own class methods for empty module" do
+      Reflexive::Methods.new(nil).
+              send(:collect_instance_methods, ::CollectInstanceMethodsEmptyM.singleton_class).
+              should == nil
+    end
+  end
+
   describe "ModuleInclusionC" do
-    module ModuleInclusionA
+    module ::ModuleInclusionA
       def module_instance_from_A_WTF!
       end
     end
 
-    module ModuleInclusionB
-      include ModuleInclusionA
+    module ::ModuleInclusionB
+      include ::ModuleInclusionA
 
       def module_instance_from_B_WTF!
       end
     end
 
-    module ModuleInclusionC
-      include ModuleInclusionB
+    module ::ModuleInclusionC
+      include ::ModuleInclusionB
+    end
+
+    it "has ModuleInclusionA and ModuleInclusionB ancestors" do
+      ModuleInclusionC.ancestors.should =~ [ ModuleInclusionC,
+                                             ModuleInclusionA,
+                                             ModuleInclusionB ] 
     end
 
     it "works" do
-      ModuleInclusionC.should generate_methods(<<-METHODS_PP)
+      ::ModuleInclusionC.should generate_methods(<<-METHODS_PP)
       [{"[M] ModuleInclusionB"=>
        {:instance=>{:public=>[:module_instance_from_B_WTF!]}}},
        {"[M] ModuleInclusionA"=>
@@ -41,16 +258,17 @@ describe Reflexive::Methods do
       METHODS_PP
     end
   end
+  
   describe "Inheritance" do
-    class InheritanceA
+    class ::InheritanceA
       def self.singleton_inherited_from_A_WTF!
       end
     end
 
-    class InheritanceB < InheritanceA
+    class ::InheritanceB < ::InheritanceA
     end
 
-    class InheritanceC < InheritanceB
+    class ::InheritanceC < ::InheritanceB
       def test
       end
     end
@@ -64,19 +282,19 @@ describe Reflexive::Methods do
   end
 
   describe "SingletonAndInstance" do
-    module M
+    module ::M
       def instance_from_moduleWTF!
       end
     end
 
-    module SM
+    module ::SM
       def singleton_from_moduleWTF!
       end
     end
 
-    class SingletonAndInstanceTest
-      include M
-      extend SM
+    class ::SingletonAndInstanceTest
+      include ::M
+      extend ::SM
 
       def self.singletonWTF!
       end
@@ -97,7 +315,7 @@ describe Reflexive::Methods do
   end
 
   describe "ExtendWithInstanceAndClass" do
-    module ExtendWithInstanceAndClassM
+    module ::ExtendWithInstanceAndClassM
       def self.singleton_WTF!
       end
 
@@ -105,19 +323,19 @@ describe Reflexive::Methods do
       end
     end
 
-    class ExtendWithInstanceAndClass
-      extend ExtendWithInstanceAndClassM
+    class ::ExtendWithInstanceAndClass
+      extend ::ExtendWithInstanceAndClassM
     end
 
     it "works" do
-      ExtendWithInstanceAndClass.should generate_methods(<<-METHODS_PP)
+      ::ExtendWithInstanceAndClass.should generate_methods(<<-METHODS_PP)
       [{"S[M] ExtendWithInstanceAndClassM"=>{:class=>{:public=>[:instance_WTF!]}}}]
       METHODS_PP
     end
   end
 
   describe "SingletonVisibility" do
-    class SingletonVisibility
+    class ::SingletonVisibility
       def self.class_method
       end
 
@@ -138,7 +356,7 @@ describe Reflexive::Methods do
     end
 
     it "works" do
-      SingletonVisibility.should generate_methods(<<-METHODS_PP)
+      ::SingletonVisibility.should generate_methods(<<-METHODS_PP)
       [{"[C] SingletonVisibility"=>
          {:class=>
            {:public=>[:class_method, :public_singleton_method],
@@ -149,28 +367,28 @@ describe Reflexive::Methods do
   end
 
   describe "SingletonOverrides" do
-    class SingletonOverridesA
+    class ::SingletonOverridesA
       def self.overriden
         puts "A"
         # super
       end
     end
 
-    module SingletonOverridesMB
+    module ::SingletonOverridesMB
       def overriden
         puts "  MB"
         super
       end
     end
 
-    class SingletonOverridesB < SingletonOverridesA
-      extend SingletonOverridesMB
+    class ::SingletonOverridesB < ::SingletonOverridesA
+      extend ::SingletonOverridesMB
 
       def self.overriden
       end
     end
 
-    module SingletonOverridesMC
+    module ::SingletonOverridesMC
       def overriden
       end
 
@@ -178,8 +396,8 @@ describe Reflexive::Methods do
       end
     end
 
-    class SingletonOverridesC < SingletonOverridesB
-      extend SingletonOverridesMC
+    class ::SingletonOverridesC < ::SingletonOverridesB
+      extend ::SingletonOverridesMC
 
       def self.class_WTF
       end
@@ -189,7 +407,7 @@ describe Reflexive::Methods do
     end
     
     it "works" do
-      SingletonOverridesC.should generate_methods(<<-METHODS_PP)
+      ::SingletonOverridesC.should generate_methods(<<-METHODS_PP)
         [{"[C] SingletonOverridesC"=>{:class=>{:public=>[:class_WTF, :overriden]}}},
          {"S[M] SingletonOverridesMC"=>
            {:class=>{:public=>[:overriden, :singleton_WTF]}}},