ruby_ext 0.4.25 → 0.5.1

data/spec/core/module_spec.rb

@@ -12,7 +12,7 @@ describe "Module" do
       InheritableAccessorB
     )
   end
-  
+
   it "Namespace" do
     class A
       class B
@@ -21,19 +21,19 @@ describe "Module" do
         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  
-  
+  # end
+
   it "name" do
     class A
       class B
@@ -42,15 +42,15 @@ describe "Module" do
         end
       end
     end
-    
+
     A::B::C.name.should == "A::B::C"
   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
@@ -58,7 +58,7 @@ describe "Module" do
     list.should_not include Z
     list.should_not include Object
     list.should_not include Kernel
-    
+
     list = []
     Z.each_ancestor(true){|a| list << a}
     list.should include Y
@@ -67,7 +67,7 @@ describe "Module" do
     list.should include Object
     list.should include Kernel
   end
-  
+
   it "each_namespace" do
     class A
       class B
@@ -76,33 +76,26 @@ describe "Module" do
         end
       end
     end
-    
+
     list = []
     A::B::C.each_namespace{|n| list << n}
     list.should == [A::B, A]
   end
-  
+
   it "is?" do
     File.is?(IO).should be_true
   end
-  
+
   class WrapMethod
     def method_name value
       10*value
     end
   end
-  
-  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  
-  
+
   it "escape_method" do
     Object.escape_method("><=?")
   end
-  
+
   it "inheritable_accessor" do
     module InheritableAccessorForModule
       module ClassMethods
@@ -110,48 +103,48 @@ describe "Module" do
         inheritable_accessor :layout, "for_module"
       end
     end
-    
+
     class InheritableAccessorForClass
       class << self
-        inheritable_accessor :callbacks2, []      
-        inheritable_accessor :layout2, "for_class"  
+        inheritable_accessor :callbacks2, []
+        inheritable_accessor :layout2, "for_class"
       end
-      callbacks2 << :set_user      
+      callbacks2 << :set_user
     end
-    
+
     class InheritableAccessor < InheritableAccessorForClass
       inherit InheritableAccessorForModule
       callbacks << :set_model
-      callbacks2 << :set_model     
-      self.layout2 = "anoter_layout" 
-    end    
-    
+      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
-  
+
   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

data/spec/core/multiple_inheritance_spec.rb

@@ -4,7 +4,7 @@ describe "Multiple Inheritance" do
   after do
     remove_constants %w(M A M2 B AddedAfterInheritance)
   end
-  
+
   it "showcase" do
     module M
       def instance_method; end
@@ -16,30 +16,30 @@ describe "Multiple Inheritance" do
       inherited do
         attr_accessor :some_accessor
       end
-    end     
-           
+    end
+
     M.should respond_to(:class_method)
 
     class A
       inherit M
     end
-    
+
     A.should respond_to(:class_method)
     A.new.should respond_to(:instance_method)
     A.new.should respond_to(:some_accessor)
-    
-    M.directly_included_by.should == [A].to_set    
-  end  
+
+    M.directly_included_by.should == [A].to_set
+  end
 
   it "should inherit all ancestors class methods" do
     module M
       def instance_method; end
 
-      class_methods do        
+      class_methods do
         def class_method; end
       end
     end
-    
+
     module M2
       inherit M
 
@@ -51,24 +51,24 @@ describe "Multiple Inheritance" do
     class B
       inherit M2
     end
-    
+
     M2.should respond_to(:class_method)
-    
+
     B.should respond_to(:class_method)
     B.should respond_to(:class_method2)
     B.new.should respond_to(:instance_method)
-    
+
     M.directly_included_by.should == [M2].to_set
     M2.directly_included_by.should == [B].to_set
   end
-  
+
   it "shouldn't redefine ancestors class methods" do
     module M
       class_methods do
         def class_method; end
       end
     end
-    
+
     module M2
       inherit M
 
@@ -76,71 +76,71 @@ describe "Multiple Inheritance" do
         def class_method2; end
       end
     end
-    
+
     class A
       inherit M
     end
-    
+
     A.should_not respond_to(:class_method2)
   end
-  
+
   it "should also allow to explicitly use ClassMethods prototype (from error)" do
     module A
       module ClassMethods
         attr_accessor :callbacks
       end
     end
-    
+
     class B
       inherit A
     end
-    
+
     B.should respond_to(:callbacks)
   end
-  
+
   it "methods defined on base class after inheritance must be propagated to all descendants" do
-    module M; end            
-    
+    module M; end
+
     class A
       inherit M
     end
-    
+
     A.instance_methods.should_not include(:method_added_after_inheritance)
     M.send(:define_method, :method_added_after_inheritance){}
     M.instance_methods.should include(:method_added_after_inheritance)
     A.instance_methods.should include(:method_added_after_inheritance)
   end
-  
+
   it "modules included in base class after inheritance must be propagated to all descendants" do
     module M; end
-    
+
     class A
       inherit M
     end
-    
+
     module AddedAfterInheritance
       def module_added_after_inheritance; end
     end
-    
+
     M.instance_methods.should_not include(:module_added_after_inheritance)
     M.inherit AddedAfterInheritance
     M.instance_methods.should include(:module_added_after_inheritance)
     A.instance_methods.should include(:module_added_after_inheritance)
   end
-  
+
   it "use case from error" do
     class ItemSpec
     end
-    
+
     class PageSpec < ItemSpec
     end
-    
+
     module ::ItemSpecHelper
     end
-    
+
     module ::PageSpecHelper
     end
-    
+
     ItemSpec.inherit ItemSpecHelper
     PageSpec.inherit PageSpecHelper
   end

data/spec/core/must_spec.rb

@@ -13,19 +13,19 @@ describe 'Assert' do
     "".must_be.a String
     "".must_be.a String, Symbol
     1.must_be.< 2
-    
+
     1.must_be.defined
     -> {nil.must_be.defined}.should raise_error(/must be defined/)
-  end   
-  
+  end
+
   it 'must_be & must_not_be' do
-    [].must_be.empty    
+    [].must_be.empty
     [''].must_not_be.empty
-    
+
     -> {[''].must_be.empty}.should raise_error(/must be/)
     -> {[].must_not_be.empty}.should raise_error(/must not be/)
   end
-  
+
   it "should return result" do
     [].must_be.empty.should == []
   end

data/spec/core/object_spec.rb

@@ -0,0 +1,15 @@
+require "core/spec_helper"
+
+describe 'Object' do
+  after(:all){remove_constants :RespondTest}
+
+  it "respond_to" do
+    class RespondTest
+      def test; 2 end
+    end
+    
+    r = RespondTest.new
+    r.respond_to(:not_exist).should be_nil
+    r.respond_to(:test).should == 2
+  end
+end

data/spec/core/open_object_spec.rb

@@ -4,25 +4,25 @@ describe 'OpenObject' do
   it 'should be comparable with hashes' do
     {}.to_openobject.should == {}
     {}.should == {}.to_openobject
-    
+
     {a: :b}.to_openobject.should == {a: :b}
     {'a' => :b}.to_openobject.should == {a: :b}
-    
+
     {a: :b}.to_openobject.should == {'a' => :b}
     {'a' => :b}.to_openobject.should == {'a' => :b}
-    
+
     {a: :b}.to_openobject.should_not == {a: :c}
   end
-  
+
   it "must be hash (from error)" do
     {}.to_openobject.is_a?(Hash).should be_true
   end
-  
+
   it 'merge! should be indifferent to string and symbol' do
     oo = OpenObject.new
     oo.merge! a: true
     oo.a.should be_true
-    oo.merge! 'b' => true    
+    oo.merge! 'b' => true
     oo.b.should be_true
   end
 end

data/spec/more/callbacks_spec.rb

@@ -0,0 +1,155 @@
+require 'more/spec_helper'
+
+describe "Callbacks" do
+  before :all do
+    class BasicCallbacksSpec
+      inherit RubyExt::Callbacks
+
+      set_callback :callback_name, :before, :before_callback
+      set_callback :callback_name, :after, :after_callback
+      set_callback :callback_name, :around, :around_callback
+
+      protected
+        def around_callback
+          around_callback_called
+          yield
+        end
+    end
+  end
+  
+  it "basic" do
+    o = BasicCallbacksSpec.new
+    o.should_receive :before_callback
+    o.should_receive :around_callback_called
+    o.should_receive :after_callback
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+  end
+
+  it "blocks" do
+    class BlockCallbacksSpec
+      inherit RubyExt::Callbacks
+      
+      set_callback(:callback_name, :before){|controller| controller.result << :before}
+      set_callback :callback_name, :around do |controller, block|
+        begin
+          controller.result << :around_begin
+          block.call
+        ensure
+          controller.result << :around_end
+        end
+      end
+      set_callback(:callback_name, :after){|controller| controller.result << :after}      
+
+      def result
+        @result ||= []
+      end
+    end
+    
+    o = BlockCallbacksSpec.new
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+    o.result.should == [:before, :around_begin, :after, :around_end]
+  end
+
+  it "inheritance" do
+    class InheritedCallbacksSpec < BasicCallbacksSpec
+      set_callback :callback_name, :before, :before_callback2
+    end
+    
+    o = InheritedCallbacksSpec.new
+    o.should_receive :before_callback
+    o.should_receive :before_callback2
+    o.should_receive :around_callback_called
+    o.should_receive :after_callback
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+  end
+  
+  it 'terminator' do
+    class CallbackTerminatorSpec
+      inherit RubyExt::Callbacks
+
+      set_callback :callback_name, :before, :before_callback, terminator: false
+      set_callback :callback_name, :before, :before_callback2      
+
+      def method
+        run_callbacks :callback_name do
+          "result"
+        end
+      end
+
+      protected
+        def before_callback
+          false 
+        end
+    end
+    
+    o = CallbackTerminatorSpec.new
+    o.should_not_receive :before_callback2
+    o.run_callbacks(:callback_name){"result"}.should_not == "result"
+  end
+  
+  it 'conditions' do
+    class CallbackConditionsSpec
+      inherit RubyExt::Callbacks
+
+      set_callback :callback_name, :before, :before_callback, only: :another_method
+    end
+    
+    o = CallbackConditionsSpec.new
+    o.should_not_receive :before_callback
+    o.run_callbacks(:callback_name, method: :method){"result"}.should == 'result'
+    
+    o = CallbackConditionsSpec.new
+    o.should_receive :before_callback
+    o.run_callbacks(:callback_name, method: :another_method){"result"}.should == 'result'
+  end
+  
+  it "if, unless conditions" do
+    c = RubyExt::Callbacks::AbstractCallback.new
+    c.conditions = {if: lambda{|target, inf| true}}
+    c.run?(nil, {}).should be_true
+    
+    c.conditions = {if: lambda{|target, inf| false}}
+    c.run?(nil, {}).should be_false
+    
+    c.conditions = {unless: lambda{|target, inf| true}}
+    c.run?(nil, {}).should be_false
+    
+    c.conditions = {unless: lambda{|target, inf| false}}
+    c.run?(nil, {}).should be_true
+  end
+  
+  it "only, except conditions" do
+    c = RubyExt::Callbacks::AbstractCallback.new
+    c.conditions = {only: :a}
+    c.run?(nil, {method: :a}).should be_true
+    
+    c.conditions = {only: :b}
+    c.run?(nil, {method: :a}).should be_false
+    
+    c.conditions = {except: :a}
+    c.run?(nil, {method: :a}).should be_false
+    
+    c.conditions = {except: :b}
+    c.run?(nil, {method: :a}).should be_true
+    
+    c.conditions = {only: :a}
+    c.run?(nil, {method: :a}).should be_true
+  end
+  
+  
+  it "around callback should be able to change result value" do
+    class ChangeResultValueSpec
+      inherit RubyExt::Callbacks
+  
+      set_callback :callback_name, :around, :around_callback
+      
+      def around_callback        
+        yield
+        'another result'
+      end
+    end
+    
+    o = ChangeResultValueSpec.new
+    o.run_callbacks(:callback_name){"result"}.should == 'another result'
+  end
+end