extlib 0.9.2 → 0.9.3

data/lib/extlib/object.rb

@@ -4,4 +4,4 @@ class Object
       instance_variables.include?(method.to_s)
     end
   end
-end # class Object
+end # class Object

data/lib/extlib/pooling.rb

@@ -10,7 +10,7 @@ module Extlib
   # because instances are keeped in memory reused.
   #
   # Classes that include Pooling module have re-defined new
-  # method that returns instances aquired from pool.
+  # method that returns instances acquired from pool.
   #
   # Term resource is used for any type of poolable objects
   # and should NOT be thought as DataMapper Resource or
@@ -31,13 +31,14 @@ module Extlib
           loop do
             lock.synchronize do
               pools.each do |pool|
-                if pool.expired?
-                  pool.lock.synchronize do
-                    if pool.size == 0
-                      pool.dispose
-                    end
+                # This is a useful check, but non-essential, and right now it breaks lots of stuff.
+                # if pool.expired?
+                pool.lock.synchronize do
+                  if pool.reserved_count == 0
+                    pool.dispose
                   end
                 end
+                # end
               end
             end
             sleep(scavenger_interval)
@@ -95,17 +96,13 @@ module Extlib
         end
 
         def self.pool_size
-          1
-        end
-
-        def self.scavenge_interval
-          10
+          8
         end
       end
     end
 
     def release
-      @__pool.release(self)
+      @__pool.release(self) unless @__pool.nil?
     end
 
     class Pool
@@ -118,9 +115,7 @@ module Extlib
         @args = args
 
         @available = []
-        @reserved = Set.new
-
-        Extlib::Pooling::append_pool(self)
+        @reserved_count = 0
       end
 
       def lock
@@ -135,15 +130,17 @@ module Extlib
         instance = nil
 
         lock.synchronize do
-          instance = aquire
+          instance = acquire
         end
 
+        Extlib::Pooling::append_pool(self)
+
         if instance.nil?
           # Account for the current thread, and the pool scavenger.
-          if ThreadGroup::Default.list.size == 2 && @reserved.size >= @max_size
+          if ThreadGroup::Default.list.size == 2 && @reserved_count >= @max_size
             raise ThreadStopError.new(size)
           else
-            sleep(0.01)
+            sleep(0.05)
             new
           end
         else
@@ -153,52 +150,62 @@ module Extlib
 
       def release(instance)
         lock.synchronize do
-          raise OrphanedObjectError.new(instance) unless @reserved.delete?(instance)
           instance.instance_variable_set(:@__pool, nil)
+          @reserved_count -= 1
           @available.push(instance)
         end
         nil
       end
 
+      def delete(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @reserved_count -= 1
+        end
+        nil
+      end
+
       def size
-        @available.size + @reserved.size
+        @available.size + @reserved_count
       end
       alias length size
 
       def inspect
-        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved=#{@reserved.size}>"
+        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved_count=#{@reserved_count}>"
       end
 
       def flush!
-        lock.synchronize do
-          @available.each do |instance|
-            instance.dispose
-          end
-          @available.clear
-        end
+        @available.pop.dispose until @available.empty?
       end
 
       def dispose
+        flush!
         @resource.__pools.delete(@args)
         !Extlib::Pooling::pools.delete?(self).nil?
       end
 
-      def expired?
-        lock.synchronize do
-          @available.each do |instance|
-            if instance.instance_variable_get(:@__allocated_in_pool) + scavenge_interval < Time.now
-              instance.dispose
-              @available.delete(instance)
-            end
-          end
-
-          size == 0
-        end
+      # Disabled temporarily.
+      #
+      # def expired?
+      #   lock.synchronize do
+      #     @available.each do |instance|
+      #       if instance.instance_variable_get(:@__allocated_in_pool) + scavenge_interval < Time.now
+      #         instance.dispose
+      #         @available.delete(instance)
+      #       end
+      #     end
+      #
+      #     size == 0
+      #   end
+      # end
+
+      def reserved_count
+        @reserved_count
       end
 
       private
 
-      def aquire
+      def acquire
         instance = if !@available.empty?
           @available.pop
         elsif size < @max_size
@@ -211,7 +218,7 @@ module Extlib
           instance
         else
           raise CrossPoolError.new(instance) if instance.instance_variable_get(:@__pool)
-          @reserved << instance
+          @reserved_count += 1
           instance.instance_variable_set(:@__pool, self)
           instance.instance_variable_set(:@__allocated_in_pool, Time.now)
           instance
@@ -219,7 +226,6 @@ module Extlib
       end
     end
 
-    private
     def self.scavenger_interval
       60
     end

data/lib/extlib/version.rb

@@ -0,0 +1,3 @@
+module Extlib
+  VERSION = "0.9.3"
+end

data/spec/hook_spec.rb

@@ -124,6 +124,21 @@ describe Extlib::Hook do
          @class.hookable!
          @class.hookable?
       end
+
+      it "should allow hooking methods that have single character names" do
+        @class.class_eval do
+          def self.a; end;
+          def self.b; end;
+        end
+
+        @class.before_class_method(:a) { omg! }
+        @class.before_class_method(:b) { hi2u! }
+
+        @class.should_receive(:omg!).once.ordered
+        @class.should_receive(:hi2u!).once.ordered
+        @class.a
+        @class.b
+      end
     end
 
     describe "for instance methods" do
@@ -217,6 +232,22 @@ describe Extlib::Hook do
         inst.hookable = 'hello'
         inst.hookable?
       end
+
+      it "should allow hooking methods that have single character names" do
+        @class.class_eval do
+          def a; end;
+          def b; end;
+        end
+
+        @class.before(:a) { omg! }
+        @class.before(:b) { hi2u! }
+
+        inst = @class.new
+        inst.should_receive(:omg!).once.ordered
+        inst.should_receive(:hi2u!).once.ordered
+        inst.a
+        inst.b
+      end
     end
 
   end
@@ -337,21 +368,94 @@ describe Extlib::Hook do
         @class.clakable
       end
 
-      it 'should pass the hookable method arguments to the hook method' do
-        @class.class_eval %{def self.hook_this(word, lol); end;}
-        @class.register_class_hooks(:hook_this)
-        @class.before_class_method(:hook_this, :before_hook_this)
+      it "should not pass any of the hookable method's arguments if the hook block does not accept arguments" do
+        @class.class_eval do
+          def self.method_with_args(one, two, three); end;
+          before_class_method(:method_with_args) { hi_mom! }
+        end
+
+        @class.should_receive(:hi_mom!)
+        @class.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook method does not accept arguments" do
+        @class.class_eval do
+          def self.method_with_args(one, two, three); end;
+          def self.before_method_with_args; hi_mom!; end;
+          before_class_method(:method_with_args, :before_method_with_args)
+        end
+
+        @class.should_receive(:hi_mom!)
+        @class.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook is declared after it is registered and does not accept arguments" do
+        @class.class_eval do
+          def self.method_with_args(one, two, three); end;
+          before_class_method(:method_with_args, :before_method_with_args)
+          def self.before_method_with_args; hi_mom!; end;
+        end
+
+        @class.should_receive(:hi_mom!)
+        @class.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook has been re-defined not to accept arguments" do
+        @class.class_eval do
+          def self.method_with_args(one, two, three); end;
+          def self.before_method_with_args(one, two, three); hi_mom!; end;
+          before_class_method(:method_with_args, :before_method_with_args)
+          def self.before_method_with_args; hi_dad!; end;
+        end
+
+        @class.should_not_receive(:hi_mom1)
+        @class.should_receive(:hi_dad!)
+        @class.method_with_args(1, 2, 3)
+      end
+
+      it 'should pass the hookable method arguments to the hook method if the hook method takes arguments' do
+        @class.class_eval do
+          def self.hook_this(word, lol); end;
+          register_class_hooks(:hook_this)
+          def self.before_hook_this(word, lol); hi_mom!(word, lol); end;
+          before_class_method(:hook_this, :before_hook_this)
+        end
 
-        @class.should_receive(:before_hook_this).with("omg", "hi2u")
+        @class.should_receive(:hi_mom!).with("omg", "hi2u")
         @class.hook_this("omg", "hi2u")
       end
 
+      it "should pass the hookable method arguments to the hook block if the hook block takes arguments" do
+        @class.class_eval do
+          def self.method_with_args(word, lol); end;
+          before_class_method(:method_with_args) { |one, two| hi_mom!(one, two) }
+        end
+
+        @class.should_receive(:hi_mom!).with('omg', 'hi2u')
+        @class.method_with_args('omg', 'hi2u')
+      end
+
+      it 'should pass the hookable method arguments to the hook method if the hook method was re-defined to accept arguments' do
+        @class.class_eval do
+          def self.method_with_args(word, lol); end;
+          def self.before_method_with_args; hi_mom!; end;
+          before_class_method(:method_with_args, :before_method_with_args)
+          def self.before_method_with_args(word, lol); hi_dad!(word, lol); end;
+        end
+
+        @class.should_not_receive(:hi_mom!)
+        @class.should_receive(:hi_dad!).with("omg", "hi2u")
+        @class.method_with_args("omg", "hi2u")
+      end
+
       it 'should work with glob arguments (or whatever you call em)' do
-        @class.class_eval %{def self.hook_this(*args); end;}
-        @class.register_class_hooks(:hook_this)
-        @class.before_class_method(:hook_this, :before_hook_this)
+        @class.class_eval do
+          def self.hook_this(*args); end;
+          def self.before_hook_this(*args); hi_mom!(*args); end;
+          before_class_method(:hook_this, :before_hook_this)
+        end
 
-        @class.should_receive(:before_hook_this).with("omg", "hi2u", "lolercoaster")
+        @class.should_receive(:hi_mom!).with("omg", "hi2u", "lolercoaster")
         @class.hook_this("omg", "hi2u", "lolercoaster")
       end
 
@@ -364,6 +468,19 @@ describe Extlib::Hook do
         @class.should_receive(:last!).once.ordered
         @class.clakable
       end
+
+      it 'should be able to use private methods as hooks' do
+        @class.class_eval do
+          class << self
+            private
+            def nike; doit!; end;
+          end
+          before_class_method(:clakable, :nike)
+        end
+
+        @class.should_receive(:doit!)
+        @class.clakable
+      end
     end
 
     describe "for instance methods" do
@@ -384,23 +501,113 @@ describe Extlib::Hook do
         inst.hookable
       end
 
-      it 'should pass the hookable method arguments to the hook method' do
-        @class.class_eval %{def hook_this(word, lol); end;}
-        @class.register_instance_hooks(:hook_this)
-        @class.before(:hook_this, :before_hook_this)
+      it "should not pass any of the hookable method's arguments if the hook block does not accept arguments" do
+        @class.class_eval do
+          def method_with_args(one, two, three); end;
+          before(:method_with_args) { hi_mom! }
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!)
+        inst.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook method does not accept arguments" do
+        @class.class_eval do
+          def method_with_args(one, two, three); end;
+          def before_method_with_args; hi_mom!; end;
+          before(:method_with_args, :before_method_with_args)
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!)
+        inst.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook is declared after it is registered and does not accept arguments" do
+        @class.class_eval do
+          def method_with_args(one, two, three); end;
+          before(:method_with_args, :before_method_with_args)
+          def before_method_with_args; hi_mom!; end;
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!)
+        inst.method_with_args(1, 2, 3)
+      end
+
+      it "should not pass any of the hookable method's arguments if the hook has been re-defined not to accept arguments" do
+        @class.class_eval do
+          def method_with_args(one, two, three); end;
+          def before_method_with_args(one, two, three); hi_mom!; end;
+          before(:method_with_args, :before_method_with_args)
+          def before_method_with_args; hi_dad!; end;
+        end
 
         inst = @class.new
-        inst.should_receive(:before_hook_this).with("omg", "hi2u")
-        inst.hook_this("omg", "hi2u")
+        inst.should_not_receive(:hi_mom1)
+        inst.should_receive(:hi_dad!)
+        inst.method_with_args(1, 2, 3)
+      end
+
+      it 'should pass the hookable method arguments to the hook method if the hook method takes arguments' do
+        @class.class_eval do
+          def method_with_args(word, lol); end;
+          def before_method_with_args(one, two); hi_mom!(one, two); end;
+          before(:method_with_args, :before_method_with_args)
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!).with("omg", "hi2u")
+        inst.method_with_args("omg", "hi2u")
+      end
+
+      it "should pass the hookable method arguments to the hook block if the hook block takes arguments" do
+        @class.class_eval do
+          def method_with_args(word, lol); end;
+          before(:method_with_args) { |one, two| hi_mom!(one, two) }
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!).with('omg', 'hi2u')
+        inst.method_with_args('omg', 'hi2u')
+      end
+
+      it 'should pass the hookable method arguments to the hook method if the hook method was re-defined to accept arguments' do
+        @class.class_eval do
+          def method_with_args(word, lol); end;
+          def before_method_with_args; hi_mom!; end;
+          before(:method_with_args, :before_method_with_args)
+          def before_method_with_args(word, lol); hi_dad!(word, lol); end;
+        end
+
+        inst = @class.new
+        inst.should_not_receive(:hi_mom!)
+        inst.should_receive(:hi_dad!).with("omg", "hi2u")
+        inst.method_with_args("omg", "hi2u")
+      end
+
+      it "should not pass the method return value to the after hook if the method does not take arguments" do
+        @class.class_eval do
+          def method_with_ret_val; 'hello'; end;
+          def after_method_with_ret_val; hi_mom!; end;
+          after(:method_with_ret_val, :after_method_with_ret_val)
+        end
+
+        inst = @class.new
+        inst.should_receive(:hi_mom!)
+        inst.method_with_ret_val
       end
 
       it 'should work with glob arguments (or whatever you call em)' do
-        @class.class_eval %{def hook_this(*args); end;}
-        @class.register_instance_hooks(:hook_this)
-        @class.before(:hook_this, :before_hook_this)
+        @class.class_eval do
+          def hook_this(*args); end;
+          def before_hook_this(*args); hi_mom!(*args) end;
+          before(:hook_this, :before_hook_this)
+        end
 
         inst = @class.new
-        inst.should_receive(:before_hook_this).with("omg", "hi2u", "lolercoaster")
+        inst.should_receive(:hi_mom!).with("omg", "hi2u", "lolercoaster")
         inst.hook_this("omg", "hi2u", "lolercoaster")
       end
 
@@ -540,8 +747,6 @@ describe Extlib::Hook do
         inst.hookable
       end
 
-
-
       it 'should not call the hook stack if the hookable method is overwritten and does not call super' do
         @class.before(:hookable) { hi_mom! }
         @child = Class.new(@class) do
@@ -736,6 +941,36 @@ describe Extlib::Hook do
         @class.hello.should == "hello world"
       end
 
+      it "should pass the return value to a hook method" do
+        @class.class_eval do
+          def self.with_return_val; 'hello'; end;
+          def self.after_with_return_val(retval); retval.should == 'hello'; end;
+          after_class_method(:with_return_val, :after_with_return_val)
+        end
+
+        @class.with_return_val
+      end
+
+      it "should pass the return value to a hook block" do
+        @class.class_eval do
+          def self.with_return_val; 'hello'; end;
+          after_class_method(:with_return_val) { |ret| ret.should == 'hello' }
+        end
+
+        @class.with_return_val
+      end
+
+      it "should pass the return value and method arguments to a hook block" do
+        @class.class_eval do
+          def self.with_args_and_return_val(world); 'hello'; end;
+          after_class_method(:with_args_and_return_val) do |hello, world|
+            hello.should == "hello"
+            world.should == "world"
+          end
+        end
+
+        @class.with_args_and_return_val('world')
+      end
     end
 
     describe "for instance methods" do
@@ -771,6 +1006,44 @@ describe Extlib::Hook do
         @class.new.hello.should == "hello world"
       end
 
+      it "should return nil if an after hook throws :halt without a return value" do
+        @class.class_eval %{def with_value; "hello"; end;}
+        @class.register_instance_hooks(:with_value)
+        @class.after(:with_value) { throw :halt }
+
+        @class.new.with_value.should be_nil
+      end
+
+      it "should pass the return value to a hook method" do
+        @class.class_eval do
+          def with_return_val; 'hello'; end;
+          def after_with_return_val(retval); retval.should == 'hello'; end;
+          after(:with_return_val, :after_with_return_val)
+        end
+
+        @class.new.with_return_val
+      end
+
+      it "should pass the return value to a hook block" do
+        @class.class_eval do
+          def with_return_val; 'hello'; end;
+          after(:with_return_val) { |ret| ret.should == 'hello' }
+        end
+
+        @class.new.with_return_val
+      end
+
+      it "should pass the return value and method arguments to a hook block" do
+        @class.class_eval do
+          def with_args_and_return_val(world); 'hello'; end;
+          after(:with_args_and_return_val) do |hello, world|
+            hello.should == "hello"
+            world.should == "world"
+          end
+        end
+
+        @class.new.with_args_and_return_val('world')
+      end
     end
 
   end
@@ -815,12 +1088,12 @@ describe Extlib::Hook do
         lambda { @class.clakable }.should_not throw_symbol(:halt)
       end
 
-      it "should still return the hookable methods return value if an after hook throws :halt" do
+      it "should return nil if an after hook throws :halt without a return value" do
         @class.class_eval %{def self.with_value; "hello"; end;}
         @class.register_class_hooks(:with_value)
         @class.after_class_method(:with_value) { throw :halt }
 
-        @class.with_value.should == "hello"
+        @class.with_value.should be_nil
       end
     end
 
@@ -864,14 +1137,42 @@ describe Extlib::Hook do
         inst.should_not_receive(:never_see_me!)
         lambda { inst.hookable }.should_not throw_symbol(:halt)
       end
+    end
 
-      it "should still return the hookable methods return value if an after hook throws :halt" do
-        @class.class_eval %{def with_value; "hello"; end;}
-        @class.register_instance_hooks(:with_value)
-        @class.after(:with_value) { throw :halt }
+  end
+
+  describe 'aborting with return values' do
+
+    describe "for class methods" do
 
-        @class.new.with_value.should == "hello"
+      it "should be able to abort from a before hook with a return value" do
+        @class.before_class_method(:clakable) { throw :halt, 'omg' }
+        @class.clakable.should == 'omg'
       end
+
+      it "should be able to abort from an after hook with a return value" do
+        @class.after_class_method(:clakable) { throw :halt, 'omg' }
+        @class.clakable.should == 'omg'
+      end
+
+    end
+
+    describe "for instance methods" do
+
+      it "should be able to abort from a before hook with a return value" do
+        @class.before(:hookable) { throw :halt, 'omg' }
+
+        inst = @class.new
+        inst.hookable.should == 'omg'
+      end
+
+      it "should be able to abort from an after hook with a return value" do
+        @class.after(:hookable) { throw :halt, 'omg' }
+
+        inst = @class.new
+        inst.hookable.should == 'omg'
+      end
+
     end
 
   end
@@ -888,9 +1189,9 @@ describe Extlib::Hook do
         end
       end
 
-      @class.args_for(@class.instance_method(:hookable)).should == ""
-      @class.args_for(@class.instance_method(:some_method)).should == "_1, _2, _3"
-      @class.args_for(@class.instance_method(:yet_another)).should == "_1, *args"
+      @class.args_for(@class.instance_method(:hookable)).should == "&block"
+      @class.args_for(@class.instance_method(:some_method)).should == "_1, _2, _3, &block"
+      @class.args_for(@class.instance_method(:yet_another)).should == "_1, *args, &block"
     end
   end