data_objects 0.9.9 → 0.9.10

data/Manifest.txt

@@ -13,7 +13,6 @@ lib/data_objects/logger.rb
 lib/data_objects/quoting.rb
 lib/data_objects/reader.rb
 lib/data_objects/result.rb
-lib/data_objects/support/pooling.rb
 lib/data_objects/transaction.rb
 lib/data_objects/uri.rb
 lib/data_objects/version.rb
@@ -25,5 +24,5 @@ spec/reader_spec.rb
 spec/result_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
-spec/support/pooling_spec.rb
 spec/transaction_spec.rb
+spec/uri_spec.rb

data/Rakefile

@@ -1,9 +1,12 @@
-require 'rubygems'
 require 'pathname'
+require 'rubygems'
 require 'spec/rake/spectask'
 require 'lib/data_objects/version'
 
-ROOT = Pathname(__FILE__).dirname.expand_path
+ROOT    = Pathname(__FILE__).dirname.expand_path
+JRUBY   = RUBY_PLATFORM =~ /java/
+WINDOWS = Gem.win_platform?
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
 
 AUTHOR = "Yehuda Katz"
 EMAIL  = "wycats@gmail.com"
@@ -17,25 +20,29 @@ PROJECT_NAME = "dorb"
 PROJECT_URL  = "http://rubyforge.org/projects/dorb"
 PROJECT_DESCRIPTION = PROJECT_SUMMARY = "The Core DataObjects class"
 
-DRIVER = false
+JAVA_DRIVER = false
+
+# RCov is run by default, except on the JRuby platform, or if NO_RCOV env is true
+RUN_RCOV = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
 
 if (tasks_dir = ROOT.parent + 'tasks').directory?
   require tasks_dir + 'hoe'
 end
 
-# Installation
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
 
-WINDOWS = (RUBY_PLATFORM =~ /mswin|mingw|cygwin/) rescue nil
-SUDO    = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
+# Installation
 
-desc "Install #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
 task :install => [ :package ] do
-  sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}, :verbose => false
+  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
 end
 
-desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"
 task :uninstall => [ :clobber ] do
-  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+  sudo_gem "uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x"
 end
 
 # Specs
@@ -46,7 +53,7 @@ Spec::Rake::SpecTask.new(:spec) do |t|
   t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb')
 
   begin
-    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov = RUN_RCOV
     t.rcov_opts << '--exclude' << 'spec'
     t.rcov_opts << '--text-summary'
     t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
@@ -55,14 +62,6 @@ Spec::Rake::SpecTask.new(:spec) do |t|
   end
 end
 
-# JRuby
-namespace :jruby do
-  desc "Install #{GEM_NAME} #{GEM_VERSION} with JRuby"
-  task :install => [ :package ] do
-    sh %{#{SUDO} jruby -S gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}, :verbose => false
-  end
-end
-
 namespace :ci do
 
   task :prepare do
@@ -88,4 +87,4 @@ namespace :ci do
 
 end
 
-task :ci => ["ci:spec"]
+task :ci => ["ci:spec"]

data/lib/data_objects/connection.rb

@@ -8,16 +8,36 @@ end
 module DataObjects
   class Connection
 
-    def self.new(uri)
-      uri = DataObjects::URI::parse(uri)
+    def self.new(uri_s)
+      uri = DataObjects::URI::parse(uri_s)
+
+      case uri.scheme.to_sym
+      when :java
+        warn 'JNDI URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
+        # TODO: handle jndi connection strings
+      when :jdbc
+        warn 'JDBC URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
+
+        driver_name = if uri.path.split(':').first == 'sqlite'
+          'sqlite3'
+        elsif uri.path.split(':').first == 'postgresql'
+          'postgres'
+        else
+          uri.path.split(':').first
+        end
 
-      if uri.scheme == 'jdbc'
-        driver_name = uri.path.split(':').first
+        conn_uri = uri_s # NOTE: for now, do not reformat this JDBC connection
+                         # string -- or, in other words, do not let
+                         # DataObjects::URI#to_s be called -- as it is not
+                         # correctly handling JDBC URLs, and in doing so, causing
+                         # java.sql.DriverManager.getConnection to throw a
+                         # 'No suitable driver found for...' exception.
       else
-        driver_name = uri.scheme.capitalize
+        driver_name = uri.scheme
+        conn_uri = uri
       end
 
-      DataObjects.const_get(driver_name.capitalize)::Connection.new(uri)
+      DataObjects.const_get(driver_name.capitalize)::Connection.new(conn_uri)
     end
 
     def self.inherited(target)

data/lib/data_objects/quoting.rb

@@ -45,6 +45,7 @@ module DataObjects
         when Array then quote_array(value)
         when Range then quote_range(value)
         when Symbol then quote_symbol(value)
+        when Regexp then quote_regexp(value)
         else
           if value.respond_to?(:to_sql)
             value.to_sql
@@ -93,6 +94,10 @@ module DataObjects
     def quote_range(value)
       "#{quote_value(value.first)} AND #{quote_value(value.last)}"
     end
+
+    def quote_regexp(value)
+      quote_string(value.source)
+    end
   end
 
 end

data/lib/data_objects/uri.rb

@@ -8,7 +8,7 @@ module DataObjects
     def self.parse(uri)
       return uri if uri.kind_of?(self)
       uri = Addressable::URI::parse(uri) unless uri.kind_of?(Addressable::URI)
-      self.new(uri.scheme, uri.user, uri.password, uri.host, uri.port, uri.path, uri.query, uri.fragment)
+      self.new(uri.scheme, uri.user, uri.password, uri.host, uri.port, uri.path, uri.query_values, uri.fragment)
     end
 
     def to_s
@@ -22,7 +22,11 @@ module DataObjects
       string << "#{host}"        if host
       string << ":#{port}"       if port
       string << path.to_s
-      string << "?#{query}"      if query
+      if query
+        string << "?" << query.map do |key, value|
+          "#{key}=#{value}"
+        end.join("&")
+      end
       string << "##{fragment}"   if fragment
       string
     end

data/lib/data_objects/version.rb

@@ -1,3 +1,3 @@
 module DataObjects
-  VERSION = "0.9.9" unless defined?(DataObjects::VERSION)
+  VERSION = "0.9.10" unless defined?(DataObjects::VERSION)
 end

data/lib/data_objects.rb

@@ -3,7 +3,7 @@ require 'rubygems'
 gem 'extlib', '~>0.9.8'
 require 'extlib'
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'data_objects', 'support', 'pooling'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'data_objects', 'version'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'data_objects', 'logger'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'data_objects', 'connection'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'data_objects', 'uri'))

data/spec/connection_spec.rb

@@ -40,8 +40,22 @@ describe DataObjects::Connection do
       c = DataObjects::Connection.new(Addressable::URI.parse('mock://localhost/database'))
       c.should be_kind_of(DataObjects::Mock::Connection)
 
-      c = DataObjects::Connection.new(Addressable::URI.parse('jdbc:mock://localhost/database'))
-      c.should be_kind_of(DataObjects::Mock::Connection)
+      c = DataObjects::Connection.new(Addressable::URI.parse('mock:jndi://jdbc/database'))
+      #c.should be_kind_of(DataObjects::Mock::Connection)
+    end
+
+    it "should return the Connection using username" do
+      c = DataObjects::Connection.new(Addressable::URI.parse('mock://root@localhost/database'))
+      c.instance_variable_get(:@uri).user.should == 'root'
+      c.instance_variable_get(:@uri).password.should be_nil
+
+      c = DataObjects::Connection.new(Addressable::URI.parse('mock://root:@localhost/database'))
+      c.instance_variable_get(:@uri).user.should == 'root'
+      c.instance_variable_get(:@uri).password.should == ''
+
+      c = DataObjects::Connection.new(Addressable::URI.parse('mock://root:pwd@localhost/database'))
+      c.instance_variable_get(:@uri).user.should == 'root'
+      c.instance_variable_get(:@uri).password.should == 'pwd'
     end
   end
 end

data/spec/uri_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::URI do
+  before do
+    @uri = DataObjects::URI.parse('mock://username:password@localhost:12345/path?encoding=utf8#fragment')
+  end
+
+  it "should parse the scheme part" do
+    @uri.scheme.should == "mock"
+  end
+
+  it "should parse the user part" do
+    @uri.user.should == "username"
+  end
+
+  it "should parse the password part" do
+    @uri.password.should == "password"
+  end
+
+  it "should parse the host part" do
+    @uri.host.should == "localhost"
+  end
+
+  it "should parse the port part" do
+    @uri.port.should == 12345
+  end
+
+  it "should parse the path part" do
+    @uri.path.should == "/path"
+  end
+
+  it "should parse the query part" do
+    @uri.query.should == { "encoding" => "utf8" }
+  end
+
+  it "should parse the fragment part" do
+    @uri.fragment.should == "fragment"
+  end
+
+  it "should provide a correct string representation" do
+    @uri.to_s.should == 'mock://username:password@localhost:12345/path?encoding=utf8#fragment'
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: data_objects
 version: !ruby/object:Gem::Version 
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-27 00:00:00 -08:00
+date: 2009-01-04 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,7 +69,6 @@ files:
 - lib/data_objects/quoting.rb
 - lib/data_objects/reader.rb
 - lib/data_objects/result.rb
-- lib/data_objects/support/pooling.rb
 - lib/data_objects/transaction.rb
 - lib/data_objects/uri.rb
 - lib/data_objects/version.rb
@@ -81,8 +80,8 @@ files:
 - spec/result_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
-- spec/support/pooling_spec.rb
 - spec/transaction_spec.rb
+- spec/uri_spec.rb
 has_rdoc: true
 homepage: http://rubyforge.org/projects/dorb
 post_install_message: 

data/lib/data_objects/support/pooling.rb

@@ -1,236 +0,0 @@
-require 'set'
-
-class Object
-  # ==== Notes
-  # Provides pooling support to class it got included in.
-  #
-  # Pooling of objects is a faster way of aquiring instances
-  # of objects compared to regular allocation and initialization
-  # because instances are keeped in memory reused.
-  #
-  # Classes that include Pooling module have re-defined new
-  # 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
-  # ActiveResource resource and such.
-  #
-  # In Data Objects connections are pooled so that it is
-  # unnecessary to allocate and initialize connection object
-  # each time connection is needed, like per request in a
-  # web application.
-  #
-  # Pool obviously has to be thread safe because state of
-  # object is reset when it is released.
-  module Pooling
-    def self.included(base)
-      base.send(:extend, ClassMethods)
-    end
-
-    module ClassMethods
-      # ==== Notes
-      # Initializes the pool and returns it.
-      #
-      # ==== Parameters
-      # size_limit<Fixnum>:: maximum size of the pool.
-      #
-      # ==== Returns
-      # <ResourcePool>:: initialized pool
-      def initialize_pool(size_limit, options = {})
-        @__pool.flush! if @__pool
-
-        @__pool = ResourcePool.new(size_limit, self, options)
-      end
-
-      # ==== Notes
-      # Instances of poolable resource are acquired from
-      # pool. This quires a new instance from pool and
-      # returns it.
-      #
-      # ==== Returns
-      # Resource instance acquired from the pool.
-      #
-      # ==== Raises
-      # ArgumentError:: when pool is exhausted and no instance
-      #                 can be acquired.
-      def new
-        pool.acquire
-      end
-
-      # ==== Notes
-      # Returns pool for this resource class.
-      # Initialization is done when necessary.
-      # Default size limit of the pool is 10.
-      #
-      # ==== Returns
-      # <Object::Pooling::ResourcePool>:: pool for this resource class.
-      def pool
-        @__pool ||= ResourcePool.new(10, self)
-      end
-    end
-
-    # ==== Notes
-    # Pool
-    #
-    class ResourcePool
-      attr_reader :size_limit, :class_of_resources, :expiration_period
-
-      # ==== Notes
-      # Initializes resource pool.
-      #
-      # ==== Parameters
-      # size_limit<Fixnum>:: maximum number of resources in the pool.
-      # class_of_resources<Class>:: class of resource.
-      #
-      # ==== Raises
-      # ArgumentError:: when class of resource does not implement
-      #                 dispose instance method or is not a Class.
-      def initialize(size_limit, class_of_resources, options)
-        raise ArgumentError.new("Expected class of resources to be instance of Class, got: #{class_of_resources.class}") unless class_of_resources.is_a?(Class)
-        raise ArgumentError.new("Class #{class_of_resources} must implement dispose instance method to be poolable.") unless class_of_resources.instance_methods.include?("dispose")
-
-        @size_limit         = size_limit
-        @class_of_resources = class_of_resources
-
-        @reserved  = Set.new
-        @available = []
-        @lock      = Mutex.new
-
-        initialization_args  = options.delete(:initialization_args) || []
-
-        @expiration_period   = options.delete(:expiration_period) || 60
-        @initialization_args = [*initialization_args]
-
-        @pool_expiration_thread = Thread.new do
-          while true
-            release_outdated
-
-            sleep (@expiration_period + 1)
-          end
-        end
-      end
-
-      # ==== Notes
-      # Current size of pool: number of already reserved
-      # resources.
-      def size
-        @reserved.size
-      end
-
-      # ==== Notes
-      # Indicates if pool has resources to acquire.
-      #
-      # ==== Returns
-      # <Boolean>:: true if pool has resources can be acquired,
-      #             false otherwise.
-      def available?
-        @reserved.size < size_limit
-      end
-
-      # ==== Notes
-      # Acquires last used available resource and returns it.
-      # If no resources available, current implementation
-      # throws an exception.
-      def acquire
-        @lock.synchronize do
-          if available?
-            instance = prepair_available_resource
-            @reserved << instance
-
-            instance
-          else
-            raise RuntimeError
-          end
-        end
-      end
-
-      # ==== Notes
-      # Releases previously acquired instance.
-      #
-      # ==== Parameters
-      # instance <Anything>:: previosly acquired instance.
-      #
-      # ==== Raises
-      # RuntimeError:: when given not pooled instance.
-      def release(instance)
-        @lock.synchronize do
-          if @reserved.include?(instance)
-            @reserved.delete(instance)
-            instance.dispose
-            @available << instance
-          else
-            raise RuntimeError
-          end
-        end
-      end
-
-      # ==== Notes
-      # Releases all objects in the pool.
-      #
-      # ==== Returns
-      # nil
-      def flush!
-        @reserved.each do |instance|
-          self.release(instance)
-        end
-
-        nil
-      end
-
-      # ==== Notes
-      # Check if instance has been acquired from the pool.
-      #
-      # ==== Returns
-      # <Boolean>:: true if given resource instance has been acquired from pool,
-      #             false otherwise.
-      def acquired?(instance)
-        @reserved.include?(instance)
-      end
-
-      # ==== Notes
-      # Releases instances that haven't been in use and
-      # hit the expiration period.
-      #
-      # ==== Returns
-      # nil
-      def release_outdated
-        @reserved.each do |instance|
-          release(instance) if time_to_release?(instance)
-        end
-
-        nil
-      end
-
-      # ==== Notes
-      # Checks if pooled resource instance is outdated and
-      # should be released.
-      #
-      # ==== Returns
-      # <Boolean>:: true if instance should be released, false otherwise.
-      def time_to_release?(instance)
-        (Time.now - instance.instance_variable_get("@__pool_acquire_timestamp")) > @expiration_period
-      end
-
-      protected
-
-      # ==== Notes
-      # Either allocates new resource,
-      # or takes last used available resource from
-      # the pool.
-      def prepair_available_resource
-        if @available.size > 0
-          res = @available.pop
-          res.instance_variable_set("@__pool_acquire_timestamp", Time.now)
-
-          res
-        else
-          res = @class_of_resources.allocate
-          res.send(:initialize, *@initialization_args)
-          res.instance_variable_set("@__pool_acquire_timestamp", Time.now)
-
-          res
-        end
-      end
-    end # ResourcePool
-  end
-end

data/spec/support/pooling_spec.rb

@@ -1,374 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'data_objects', 'support', 'pooling')
-require 'timeout'
-
-# This implements dispose
-# and works perfectly with
-# pooling.
-class DisposableResource
-  include Object::Pooling
-  attr_reader :name
-
-  def initialize(name = "")
-    @name = name
-  end
-
-  def dispose
-    @name = nil
-  end
-end
-
-# This baby causes exceptions
-# to be raised when you use
-# it with pooling.
-class UndisposableResource
-end
-
-describe Object::Pooling::ResourcePool do
-  before :each do
-    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, :expiration_period => 50)
-  end
-
-  it "responds to flush!" do
-    @pool.should respond_to(:flush!)
-  end
-
-  it "responds to acquire" do
-    @pool.should respond_to(:acquire)
-  end
-
-  it "responds to release" do
-    @pool.should respond_to(:release)
-  end
-
-  it "responds to :available?" do
-    @pool.should respond_to(:available?)
-  end
-
-  it "has a size limit" do
-    @pool.size_limit.should == 7
-  end
-
-  it "has initial size of zero" do
-    @pool.size.should == 0
-  end
-
-  it "has a set of reserved resources" do
-    @pool.instance_variable_get("@reserved").should be_empty
-  end
-
-  it "has a set of available resources" do
-    @pool.instance_variable_get("@available").should be_empty
-  end
-
-  it "knows class of resources (objects) it works with" do
-    @pool.class_of_resources.should == DisposableResource
-  end
-
-  it "raises exception when given anything but class for resources class" do
-    lambda {
-      @pool = Object::Pooling::ResourcePool.new(7, "Hooray!", {})
-    }.should raise_error(ArgumentError, /class/)
-  end
-
-  it "requires class of resources (objects) it works with to have a dispose instance method" do
-    lambda {
-      @pool = Object::Pooling::ResourcePool.new(3, UndisposableResource, {})
-    }.should raise_error(ArgumentError, /dispose/)
-  end
-
-  it "may take initialization arguments" do
-    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, { :initialization_args => ["paper"] })
-    @pool.instance_variable_get("@initialization_args").should == ["paper"]
-  end
-
-  it "may take expiration period option" do
-    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, { :expiration_period => 100 })
-    @pool.expiration_period.should == 100
-  end
-
-  it "has default expiration period of one minute" do
-    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, {})
-    @pool.expiration_period.should == 60
-  end
-
-  it "spawns a thread to dispose objects haven't been used for a while" do
-    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, {})
-    @pool.instance_variable_get("@pool_expiration_thread").should be_an_instance_of(Thread)
-  end
-end
-
-
-
-describe "Acquire from constant size pool" do
-  before :each do
-    DisposableResource.initialize_pool(2)
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "increased size of the pool" do
-    @time = DisposableResource.pool.acquire
-    DisposableResource.pool.size.should == 1
-  end
-
-  it "places initialized instance in the reserved set" do
-    @time = DisposableResource.pool.acquire
-    DisposableResource.pool.instance_variable_get("@reserved").size.should == 1
-  end
-
-  it "raises an exception when pool size limit is hit" do
-    @t1 = DisposableResource.pool.acquire
-    @t2 = DisposableResource.pool.acquire
-
-    lambda { DisposableResource.pool.acquire }.should raise_error(RuntimeError)
-  end
-
-  it "returns last released resource" do
-    @t1 = DisposableResource.pool.acquire
-    @t2 = DisposableResource.pool.acquire
-    DisposableResource.pool.release(@t1)
-
-    DisposableResource.pool.acquire.should == @t1
-  end
-
-  it "really truly returns last released resource" do
-    @t1 = DisposableResource.pool.acquire
-    DisposableResource.pool.release(@t1)
-
-    @t2 = DisposableResource.pool.acquire
-    DisposableResource.pool.release(@t2)
-
-    @t3 = DisposableResource.pool.acquire
-    DisposableResource.pool.release(@t3)
-
-    DisposableResource.pool.acquire.should == @t1
-    @t1.should == @t3
-  end
-
-  it "sets allocation timestamp on resource instance" do
-    @t1 = DisposableResource.new
-    @t1.instance_variable_get("@__pool_acquire_timestamp").should be_close(Time.now, 2)
-  end
-end
-
-
-
-describe "Releasing from constant size pool" do
-  before :each do
-    DisposableResource.initialize_pool(2)
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "decreases size of the pool" do
-    @t1 = DisposableResource.pool.acquire
-    @t2 = DisposableResource.pool.acquire
-    DisposableResource.pool.release(@t1)
-
-    DisposableResource.pool.size.should == 1
-  end
-
-  it "raises an exception on attempt to releases object not in pool" do
-    @t1 = DisposableResource.new
-    @t2 = Set.new
-
-    DisposableResource.pool.release(@t1)
-    lambda { DisposableResource.pool.release(@t2) }.should raise_error(RuntimeError)
-  end
-
-  it "disposes released object" do
-    @t1 = DisposableResource.pool.acquire
-
-    @t1.should_receive(:dispose)
-    DisposableResource.pool.release(@t1)
-  end
-
-  it "removes released object from reserved set" do
-    @t1 = DisposableResource.pool.acquire
-
-    lambda {
-      DisposableResource.pool.release(@t1)
-    }.should change(DisposableResource.pool.instance_variable_get("@reserved"), :size).by(-1)
-  end
-
-  it "returns released object back to available set" do
-    @t1 = DisposableResource.pool.acquire
-
-    lambda {
-      DisposableResource.pool.release(@t1)
-    }.should change(DisposableResource.pool.instance_variable_get("@available"), :size).by(1)
-  end
-
-  it "updates acquire timestamp on already allocated resource instance" do
-    # acquire it once
-    @t1 = DisposableResource.new
-    # wait a bit
-    sleep 3
-
-    # check old timestamp
-    @t1.instance_variable_get("@__pool_acquire_timestamp").should be_close(Time.now, 4)
-
-    # re-acquire
-    DisposableResource.pool.release(@t1)
-    @t1 = DisposableResource.new
-    # see timestamp is updated
-    @t1.instance_variable_get("@__pool_acquire_timestamp").should be_close(Time.now, 2)
-  end
-end
-
-
-
-describe Object::Pooling::ResourcePool, "#available?" do
-  before :each do
-    DisposableResource.initialize_pool(2)
-    DisposableResource.new
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "returns true when pool has available instances" do
-    DisposableResource.pool.should be_available
-  end
-
-  it "returns false when pool is exhausted" do
-    # acquires the last available resource
-    DisposableResource.new
-    DisposableResource.pool.should_not be_available
-  end
-end
-
-
-
-describe "Flushing of constant size pool" do
-  before :each do
-    DisposableResource.initialize_pool(2)
-
-    @t1 = DisposableResource.new
-    @t2 = DisposableResource.new
-
-    # sanity check
-    DisposableResource.pool.instance_variable_get("@reserved").should_not be_empty
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "disposes all pooled objects" do
-    [@t1, @t2].each { |instance| instance.should_receive(:dispose) }
-
-    DisposableResource.pool.flush!
-  end
-
-  it "empties reserved set" do
-    DisposableResource.pool.flush!
-
-    DisposableResource.pool.instance_variable_get("@reserved").should be_empty
-  end
-
-  it "returns all instances to available set" do
-    DisposableResource.pool.flush!
-
-    DisposableResource.pool.instance_variable_get("@available").size.should == 2
-  end
-end
-
-
-
-describe "Poolable resource class" do
-  before :each do
-    DisposableResource.initialize_pool(3, :initialization_args => ["paper"])
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "acquires new instances from pool" do
-    @instance_one = DisposableResource.new
-
-    DisposableResource.pool.acquired?(@instance_one).should be(true)
-  end
-
-  it "flushed existing pool on re-initialization" do
-    DisposableResource.pool.should_receive(:flush!)
-    DisposableResource.initialize_pool(5)
-  end
-
-  it "replaces pool on re-initialization" do
-    DisposableResource.initialize_pool(5)
-    DisposableResource.pool.size_limit.should == 5
-  end
-
-  it "passes initialization parameters to newly created resource instances" do
-    DisposableResource.new.name.should == "paper"
-  end
-end
-
-
-
-describe "Pooled object", "on initialization" do
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "does not flush pool" do
-    # using pool here initializes the pool first
-    # so we use instance variable directly
-    DisposableResource.instance_variable_get("@__pool").should_not_receive(:flush!)
-    DisposableResource.initialize_pool(23)
-  end
-
-  it "flushes pool first when re-initialized" do
-    DisposableResource.initialize_pool(5)
-    DisposableResource.pool.should_receive(:flush!)
-    DisposableResource.initialize_pool(23)
-  end
-end
-
-
-
-describe Object::Pooling::ResourcePool, "#time_to_dispose?" do
-  before :each do
-    DisposableResource.initialize_pool(7, :expiration_period => 2)
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "returns true when object's last acquisition time is greater than limit" do
-    @t1 = DisposableResource.new
-    DisposableResource.pool.time_to_release?(@t1).should be(false)
-
-    sleep 3
-    DisposableResource.pool.time_to_release?(@t1).should be(true)
-  end
-end
-
-
-
-describe Object::Pooling::ResourcePool, "#dispose_outdated" do
-  before :each do
-    DisposableResource.initialize_pool(7, :expiration_period => 2)
-  end
-
-  after :each do
-    DisposableResource.instance_variable_set("@__pool", nil)
-  end
-
-  it "releases and thus disposes outdated instances" do
-    @t1 = DisposableResource.new
-    DisposableResource.pool.should_receive(:time_to_release?).with(@t1).and_return(true)
-    DisposableResource.pool.should_receive(:release).with(@t1)
-
-    DisposableResource.pool.release_outdated
-  end
-end