spec/ruby_ext/module_spec.rb in ruby-ext-0.4.1 vs spec/ruby_ext/module_spec.rb in ruby-ext-0.4.2

@@ -1,41 +1,60 @@
-require "#{File.dirname __FILE__}/../ruby_ext_spec_helper"
+require "#{File.dirname __FILE__}/helper"
 require "ruby_ext/module"
+require 'ruby_ext/multiple_inheritance'
 
-
 describe "Module" do
-  class A
-    class B
-      class C
-        
-      end
-    end
+  after :each do
+    remove_constants %w(
+      A X Y Z
+      InheritableAccessorForModule
+      InheritableAccessorForClass
+      InheritableAccessor
+      InheritableAccessorBase
+      InheritableAccessorA
+      InheritableAccessorB
+    )
   end
   
   it "Namespace" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
     File.namespace.should == nil
     A::B::C.namespace.should == A::B
   end
   
-  class AnonymousClass
-    class << self
-      def anonymous_name
-        self.name
-      end
-    end
-  end  
+  # class AnonymousClass
+  #   class << self
+  #     def anonymous_name
+  #       self.name
+  #     end
+  #   end
+  # end  
   
   it "name" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
     A::B::C.name.should == "A::B::C"
   end
   
-  class X; end
-  class Y < X; end
-  class Z < Y; end
-  
-  
   it "each_ancestor" do
+    class X; end
+    class Y < X; end
+    class Z < Y; end
+    
     list = []
     Z.each_ancestor{|a| list << a}
     list.should include Y
     list.should include X
     list.should_not include Z
@@ -50,10 +69,18 @@
     list.should include Object
     list.should include Kernel
   end
   
   it "each_namespace" do
+    class A
+      class B
+        class C
+
+        end
+      end
+    end
+    
     list = []
     A::B::C.each_namespace{|n| list << n}
     list.should == [A::B, A]
   end
   
@@ -70,59 +97,64 @@
   it "wrap_method" do
     WrapMethod.wrap_method :method_name do |old, value|
       send(old, value)*value
     end
     WrapMethod.new.method_name(10).should == 1000
-  end
+  end  
   
-  module M
-    def m_m; end        
-    module ClassMethods
-      def cm_m; end
-    end
-  end            
-  
-  class C
-    inherit M
+  it "escape_method" do
+    Object.escape_method("><=?")
   end
   
-  it "inherit" do
-    C.respond_to?(:cm_m).should be_true
-    C.new.respond_to?(:m_m).should be_true        
-  end
-  
-  module M2
-    include M
+  it "inheritable_accessor" do
+    module InheritableAccessorForModule
+      module ClassMethods
+        inheritable_accessor :callbacks, [:set_user]
+        inheritable_accessor :layout, "for_module"
+      end
+    end
     
-    module ClassMethods
-      def cm2_m; end
+    class InheritableAccessorForClass
+      class << self
+        inheritable_accessor :callbacks2, []      
+        inheritable_accessor :layout2, "for_class"  
+      end
+      callbacks2 << :set_user      
     end
+    
+    class InheritableAccessor < InheritableAccessorForClass
+      inherit InheritableAccessorForModule
+      callbacks << :set_model
+      callbacks2 << :set_model     
+      self.layout2 = "anoter_layout" 
+    end    
+    
+    InheritableAccessorForClass.callbacks2.should == [:set_user]
+    InheritableAccessor.callbacks.should == [:set_user, :set_model]
+    InheritableAccessor.callbacks2.should == [:set_user, :set_model]
+    
+    InheritableAccessorForClass.layout2.should == "for_class"
+    InheritableAccessor.layout2.should == "anoter_layout"
+    InheritableAccessor.layout.should == "for_module"
   end
   
-  class D
-    inherit M2
-  end
-  
-  it "should inherit all ancestors class methods" do
-    D.respond_to?(:cm_m).should be_true
-    D.respond_to?(:cm2_m).should be_true
-    D.new.respond_to?(:m_m).should be_true
-  end
-  
-  class C2
-    inherit M
-  end
-  
-  it "Shouldn't redefine ancestors class methods" do
-    C2.respond_to?(:cm2_m).should be_false
-  end
-  
-  it "inherited_instance_methods" do
-    im = Set.instance_methods - Set.inherited_instance_methods
-    im.should include("union")
-    im.should_not include("object_id")
-  end
-  
-  it "escape_method" do
-    Object.escape_method("><=?")
+  it "inheritable_accessor (from error)" do
+    module InheritableAccessorBase
+      module ClassMethods
+        inheritable_accessor :callbacks, []
+      end
+    end
+    
+    class InheritableAccessorA
+      inherit InheritableAccessorBase
+      callbacks << :a
+    end
+    
+    class InheritableAccessorB
+      inherit InheritableAccessorBase
+      callbacks << :b
+    end
+    
+    InheritableAccessorA.callbacks.should == [:a]
+    InheritableAccessorB.callbacks.should == [:b]
   end
 end
\ No newline at end of file