pond 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 60082a3f35a388cf665c609388ee4025e58006d1
+  data.tar.gz: 1e0ed085f1a3f3943c85ce1f00976f2d892c1e33
+SHA512: 
+  metadata.gz: 7e1b8250177dbd7b8ee56d1750debade92eabb7ad22b9b778d72f8465083d3c0071f1674713a0d44a06aa3d6df18ac549e7bfade50c3a24293a68168dbf0dde7
+  data.tar.gz: 24b0bd2e914f6932bdb4ea2e4c532543a3a7928e8c01d11326ed44b5254c261b1ee3032408c0f42092a5a8a6bd48e6d8406b6f1ddaee3dce5ddf4fd5202b2529

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.1.0 (2014-02-14)
+
+*   Initial release.

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pond.gemspec
+gemspec
+
+gem 'rubysl', '~> 2.0', :platform => :rbx

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Chris Hanks
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# Pond
+
+Pond is a gem that offers thread-safe object pooling. It can wrap anything that is costly to instantiate, but is usually used for connections. It is intentionally very similar to the `connection_pool` gem, but is intended to be more efficient and flexible. It instantiates objects lazily by default, which is important for things with high overhead like Postgres connections. It can also be dynamically resized.
+
+Also, it was pretty fun to write.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pond'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pond
+
+## Usage
+
+    require 'pond'
+    require 'redis'
+
+    $redis_pond = Pond.new(:maximum_size => 5, :timeout => 0.5) { Redis.new }
+
+    # No connections are established until we need one:
+    $redis_pond.checkout do |redis|
+      redis.incr 'my_counter'
+      redis.lpush 'my_list', 'item'
+    end
+
+    # Alternatively, wrap it:
+    $redis = Pond.wrap(:maximum_size => 5, :timeout => 0.5) { Redis.new }
+
+    # You can now use $redis as you normally would.
+    $redis.incr 'my_counter'
+    $redis.lpush 'my_list', 'item'
+
+    $redis.pipelined do
+      # All these commands go to the same Redis connection, and so are pipelined correctly.
+      $redis.incr 'my_counter'
+      $redis.lpush 'my_list', 'item'
+    end
+
+Options:
+* :maximum_size - The maximum number of objects you want the pool to contain. The default is 10.
+* :timeout - When attempting to check out an object but none are available, how many seconds to wait before raising a `Pond::Timeout` error. The default is 1.
+* :collection - How to manage the objects in the pool. The default is :queue, meaning that pond.checkout will yield the object that hasn't been used in the longest period of time. This is to prevent connections from becoming 'stale'. The alternative is :stack, so checkout will yield the object that has most recently been returned to the pool. This would be preferable if you're using connections that have their own logic for becoming idle in periods of low activity.
+* :eager - Set this to true to fill the pool with instantiated objects when it is created, similar to how `connection_pool` works.
+
+## Contributing
+
+I don't plan on adding too many more features to Pond, since I want to keep its design simple. If there's something you'd like to see it do, open an issue so we can discuss it before going to the trouble of creating a pull request.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :default do |spec|
+  spec.pattern = './spec/**/*_spec.rb'
+end

data/lib/pond.rb

@@ -0,0 +1,136 @@
+require 'monitor'
+
+require 'pond/version'
+
+class Pond
+  class Timeout < StandardError; end
+
+  attr_reader :allocated, :available, :timeout, :collection, :maximum_size
+
+  def initialize(options = {}, &block)
+    @block   = block
+    @monitor = Monitor.new
+    @cv      = Monitor::ConditionVariable.new(@monitor)
+
+    maximum_size = options.fetch :maximum_size, 10
+
+    @allocated = {}
+    @available = Array.new(options[:eager] ? maximum_size : 0, &block)
+
+    self.timeout      = options.fetch :timeout, 1
+    self.collection   = options.fetch :collection, :queue
+    self.maximum_size = maximum_size
+  end
+
+  def checkout(&block)
+    if object = current_object
+      yield object
+    else
+      checkout_object(&block)
+    end
+  end
+
+  def size
+    sync { @available.size + @allocated.size }
+  end
+
+  def timeout=(timeout)
+    raise "Bad value for Pond timeout: #{timeout.inspect}" unless Numeric === timeout && timeout >= 0
+    sync { @timeout = timeout }
+  end
+
+  def collection=(type)
+    raise "Bad value for Pond collection: #{type.inspect}" unless [:stack, :queue].include?(type)
+    sync { @collection = type }
+  end
+
+  def maximum_size=(max)
+    raise "Bad value for Pond maximum_size: #{max.inspect}" unless Integer === max && max >= 0
+    sync do
+      @maximum_size = max
+      {} until size <= max || pop_object.nil?
+    end
+  end
+
+  private
+
+  def checkout_object
+    lock_object
+    yield current_object
+  ensure
+    unlock_object
+  end
+
+  def lock_object
+    deadline = Time.now + @timeout
+
+    until current_object
+      raise Timeout if (time_left = deadline - Time.now) < 0
+
+      sync do
+        if object = get_object(time_left)
+          set_current_object(object)
+        end
+      end
+    end
+
+    # We need to protect changes to @allocated and @available with the monitor
+    # so that #size always returns the correct value. But, we don't want to
+    # call the instantiation block while we have the lock, since it may take a
+    # long time to return. So, we set the checked-out object to the block as a
+    # signal that it needs to be called.
+    set_current_object(@block.call) if current_object == @block
+  end
+
+  def unlock_object
+    sync do
+      object = @allocated.delete(Thread.current)
+
+      if object && object != @block && size < maximum_size
+        @available << object
+        @cv.signal
+      end
+    end
+  end
+
+  def get_object(timeout)
+    pop_object || size < maximum_size && @block || @cv.wait(timeout) && false
+  end
+
+  def pop_object
+    case collection
+    when :queue then @available.shift
+    when :stack then @available.pop
+    end
+  end
+
+  def current_object
+    sync { @allocated[Thread.current] }
+  end
+
+  def set_current_object(object)
+    sync { @allocated[Thread.current] = object }
+  end
+
+  def sync(&block)
+    @monitor.synchronize(&block)
+  end
+
+  class << self
+    def wrap(*args, &block)
+      Wrapper.new(*args, &block)
+    end
+  end
+
+  class Wrapper < BasicObject
+    attr_reader :pond
+
+    def initialize(*args, &block)
+      @pond = ::Pond.new(*args, &block)
+    end
+
+    def method_missing(*args, &block)
+      @pond.checkout { |object| object.send(*args, &block) }
+    end
+  end
+end

data/lib/pond/version.rb

@@ -0,0 +1,3 @@
+class Pond
+  VERSION = '0.1.0'
+end

data/pond.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pond/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pond'
+  spec.version       = Pond::VERSION
+  spec.authors       = ["Chris Hanks"]
+  spec.email         = ["christopher.m.hanks@gmail.com"]
+  spec.description   = %q{A simple, generic, thread-safe pool for connections or whatever else}
+  spec.summary       = %q{A simple, generic, thread-safe pool}
+  spec.homepage      = 'https://github.com/chanks/pond'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rspec',   '~> 2.14'
+  spec.add_development_dependency 'rake'
+end

data/spec/checkout_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe Pond, "#checkout" do
+  it "should yield objects specified in the block" do
+    pond = Pond.new { 1 }
+    pond.checkout { |i| i.should == 1 }
+  end
+
+  it "should return the value returned by the block" do
+    pond = Pond.new { 1 }
+    value = pond.checkout { |i| 'value' }
+    value.should == 'value'
+  end
+
+  it "should instantiate objects when needed" do
+    int  = 0
+    pond = Pond.new { int += 1 }
+
+    pond.size.should == 0
+
+    pond.checkout do |i|
+      pond.available.should == []
+      pond.allocated.should == {Thread.current => 1}
+      i.should == 1
+    end
+
+    pond.available.should == [1]
+    pond.allocated.should == {}
+    pond.size.should == 1
+
+    pond.checkout do |i|
+      pond.available.should == []
+      pond.allocated.should == {Thread.current => 1}
+      i.should == 1
+    end
+
+    pond.available.should == [1]
+    pond.allocated.should == {}
+    pond.size.should == 1
+  end
+
+  it "should not instantiate objects in excess of the specified maximum_size" do
+    object = nil
+    pond = Pond.new(:maximum_size => 1) { object = Object.new }
+    object_ids = []
+
+    threads = 20.times.map do
+      pond.checkout do |obj|
+        object_ids << obj.object_id
+      end
+    end
+
+    object_ids.uniq.should == [object.object_id]
+  end
+
+  it "should give different objects to different threads" do
+    int  = 0
+    pond = Pond.new { int += 1 }
+
+    q1, q2 = Queue.new, Queue.new
+
+    t = Thread.new do
+      pond.checkout do |i|
+        i.should == 1
+        q1.push nil
+        q2.pop
+      end
+    end
+
+    q1.pop
+
+    pond.size.should == 1
+    pond.allocated.should == {t => 1}
+    pond.available.should == []
+
+    pond.checkout { |i| i.should == 2 }
+
+    pond.size.should == 2
+    pond.allocated.should == {t => 1}
+    pond.available.should == [2]
+
+    q2.push nil
+    t.join
+
+    pond.allocated.should == {}
+    pond.available.should == [2, 1]
+  end
+
+  it "should be re-entrant" do
+    pond = Pond.new { Object.new }
+    pond.checkout do |obj1|
+      pond.checkout do |obj2|
+        obj1.should == obj2
+      end
+    end
+  end
+
+  it "should support a thread checking out objects from distinct Pond instances" do
+    pond1 = Pond.new { [] }
+    pond2 = Pond.new { {} }
+
+    pond1.checkout do |one|
+      pond2.checkout do |two|
+        one.should == []
+        two.should == {}
+      end
+    end
+  end
+
+  it "should yield an object to only one thread when many are waiting" do
+    pond = Pond.new(:maximum_size => 1) { 2 }
+
+    q1, q2, q3 = Queue.new, Queue.new, Queue.new
+
+    threads = 4.times.map do
+      Thread.new do
+        Thread.current[:value] = 0
+
+        q1.push nil
+
+        pond.checkout do |o|
+          Thread.current[:value] = o
+          q2.push nil
+          q3.pop
+        end
+      end
+    end
+
+    4.times { q1.pop }
+    q2.pop
+
+    threads.map{|t| t[:value]}.sort.should == [0, 0, 0, 2]
+
+    4.times { q3.push nil }
+
+    threads.each &:join
+  end
+
+  it "should treat the collection of objects as a queue by default" do
+    int  = 0
+    pond = Pond.new { int += 1 }
+    results = []
+
+    q  = Queue.new
+    m  = Mutex.new
+    cv = ConditionVariable.new
+
+    4.times do
+      threads = 4.times.map do
+        Thread.new do
+          m.synchronize do
+            pond.checkout do |i|
+              results << i
+              q.push nil
+              cv.wait(m)
+            end
+            cv.signal
+          end
+        end
+      end
+
+      4.times { q.pop }
+      cv.signal
+      threads.each(&:join)
+    end
+
+    pond.size.should == 4
+    results.should == (1..4).cycle(4).to_a
+  end
+
+  it "should treat the collection of objects as a stack if configured that way" do
+    int  = 0
+    pond = Pond.new(:collection => :stack) { int += 1 }
+    results = []
+
+    q  = Queue.new
+    m  = Mutex.new
+    cv = ConditionVariable.new
+
+    4.times do
+      threads = 4.times.map do
+        Thread.new do
+          m.synchronize do
+            pond.checkout do |i|
+              results << i
+              q.push nil
+              cv.wait(m)
+            end
+            cv.signal
+          end
+        end
+      end
+
+      4.times { q.pop }
+      cv.signal
+      threads.each(&:join)
+    end
+
+    pond.size.should == 4
+    results.should == [1, 2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 3, 2, 1]
+  end
+
+  it "should raise a timeout error if it takes too long to return an object" do
+    pond = Pond.new(:timeout => 0.01, :maximum_size => 1){1}
+
+    q1, q2 = Queue.new, Queue.new
+    t = Thread.new do
+      pond.checkout do
+        q1.push nil
+        q2.pop
+      end
+    end
+
+    q1.pop
+
+    proc{pond.checkout{}}.should raise_error Pond::Timeout
+
+    q2.push nil
+    t.join
+  end
+
+  it "with a block that raises an error should check the object back in and propagate the error" do
+    pond = Pond.new { 1 }
+    proc do
+      pond.checkout do
+        raise "Blah!"
+      end
+    end.should raise_error RuntimeError, "Blah!"
+
+    pond.allocated.should == {}
+    pond.available.should == [1]
+  end
+
+  it "should not block other threads if the object instantiation takes a long time" do
+    t = nil
+    q1, q2, q3 = Queue.new, Queue.new, Queue.new
+    pond = Pond.new do
+      q1.push nil
+      q2.pop
+    end
+
+    q2.push 1
+
+    pond.checkout do |i|
+      q1.pop
+      i.should == 1
+
+      t = Thread.new do
+        pond.checkout do |i|
+          i.should == 2
+        end
+      end
+
+      q1.pop
+    end
+
+    pond.checkout { |i| i.should == 1 }
+
+    q2.push 2
+    t.join
+  end
+
+  it "should not leave the Pond in a bad state if object instantiation fails" do
+    int = 0
+    error = false
+    pond = Pond.new do
+      raise "Instantiation Error!" if error
+      int += 1
+    end
+
+    pond.checkout { |i| i.should == 1 }
+
+    pond.size.should == 1
+    pond.allocated.should == {}
+    pond.available.should == [1]
+
+    error = true
+
+    pond.checkout do |i|
+      i.should == 1
+
+      t = Thread.new do
+        pond.checkout{}
+      end
+
+      proc { t.join }.should raise_error RuntimeError, "Instantiation Error!"
+    end
+
+    pond.size.should == 1
+    pond.allocated.should == {}
+    pond.available.should == [1]
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Pond, "configuration" do
+  it "should eagerly instantiate objects if the option is given" do
+    int = 0
+    pond = Pond.new(:eager => true){int += 1}
+    pond.available.should == (1..10).to_a
+  end
+
+  it "should have its collection type gettable and settable" do
+    pond = Pond.new { Object.new }
+    pond.collection.should == :queue
+    pond.collection = :stack
+    pond.collection.should == :stack
+
+    pond = Pond.new(:collection => :stack) { Object.new }
+    pond.collection.should == :stack
+    pond.collection = :queue
+    pond.collection.should == :queue
+
+    procs = [
+      proc{pond.collection = nil},
+      proc{Pond.new(:collection => nil) { Object.new }},
+      proc{pond.collection = :blah},
+      proc{Pond.new(:collection => :blah) { Object.new }}
+    ]
+
+    procs.each { |p| p.should raise_error RuntimeError, /Bad value for Pond collection:/ }
+  end
+
+  it "should have its timeout gettable and settable" do
+    pond = Pond.new { Object.new }
+    pond.timeout.should == 1
+    pond.timeout = 4
+    pond.timeout.should == 4
+
+    pond = Pond.new(:timeout => 3.7) { Object.new }
+    pond.timeout.should == 3.7
+    pond.timeout = 1.9
+    pond.timeout.should == 1.9
+
+    procs = [
+      proc{pond.timeout = nil},
+      proc{Pond.new(:timeout => nil) { Object.new }},
+      proc{pond.timeout = :blah},
+      proc{Pond.new(:timeout => :blah) { Object.new }}
+    ]
+
+    procs.each { |p| p.should raise_error RuntimeError, /Bad value for Pond timeout:/ }
+  end
+
+  it "should have its maximum_size gettable and settable" do
+    pond = Pond.new { Object.new }
+    pond.maximum_size.should == 10
+    pond.maximum_size = 7
+    pond.maximum_size.should == 7
+    pond.maximum_size = 0
+    pond.maximum_size.should == 0
+    pond.maximum_size = 2
+    pond.maximum_size.should == 2
+
+    procs = [
+      proc{pond.maximum_size = nil},
+      proc{Pond.new(:maximum_size => nil) { Object.new }},
+      proc{pond.maximum_size = :blah},
+      proc{Pond.new(:maximum_size => :blah) { Object.new }},
+      proc{pond.maximum_size = 4.0},
+      proc{Pond.new(:maximum_size => 4.0) { Object.new }},
+    ]
+
+    procs.each { |p| p.should raise_error RuntimeError, /Bad value for Pond maximum_size:/ }
+  end
+
+  it "when the maximum_size is decreased should free available objects" do
+    int  = 0
+    pond = Pond.new(:eager => true) { int += 1 }
+
+    pond.available.should == (1..10).to_a
+    pond.maximum_size = 8
+    pond.available.should == (3..10).to_a
+    pond.maximum_size = 10
+    pond.available.should == (3..10).to_a
+    pond.maximum_size = 9
+    pond.available.should == (3..10).to_a
+  end
+
+  it "when the maximum_size is decreased should free available objects and checked-out objects upon return" do
+    int = 0
+    pond = Pond.new(:eager => true, :maximum_size => 2) { int += 1 }
+    pond.available.should == [1, 2]
+
+    q1, q2 = Queue.new, Queue.new
+    t = Thread.new do
+      pond.checkout do |i|
+        i.should == 1
+        q1.push nil
+        q2.pop
+      end
+    end
+
+    q1.pop
+
+    pond.maximum_size = 0
+    pond.maximum_size.should == 0
+
+    pond.size.should == 1
+    pond.available.should == []
+    pond.allocated.should == {t => 1}
+
+    q2.push nil
+    t.join
+
+    pond.size.should == 0
+    pond.available.should == []
+    pond.allocated.should == {}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'pond'

data/spec/wrapper_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Pond::Wrapper do
+  class Wrapped
+    def pipelined(&block)
+      yield
+    end
+  end
+
+  before do
+    @wrapper = Pond.wrap { Wrapped.new }
+    @pond    = @wrapper.pond
+  end
+
+  it "should proxy method calls to checked out objects" do
+    @pond.size.should == 0
+
+    @wrapper.class.should == Wrapped
+    @wrapper.respond_to?(:pipelined).should == true
+    object_id = @wrapper.object_id
+
+    @pond.size.should == 1
+    @pond.allocated.should == {}
+    @pond.available.map(&:object_id).should == [object_id]
+  end
+
+  it "should return the same object within a block passed to one of its methods" do
+    q1, q2 = Queue.new, Queue.new
+    oid1, oid2 = nil, nil
+
+    @wrapper.pipelined do
+      oid1 = @wrapper.object_id
+
+      t = Thread.new do
+        @wrapper.pipelined do
+          q1.push nil
+          q2.pop
+
+          oid2 = @wrapper.object_id
+          oid2.should == @wrapper.object_id
+          @wrapper
+        end
+      end
+
+      q1.pop
+
+      @wrapper.object_id.should == oid1
+
+      @pond.allocated.keys.should == [Thread.current, t]
+      @pond.available.should == []
+
+      q2.push nil
+      t.join
+
+      @wrapper.object_id.should == oid1
+      @wrapper.object_id.should == oid1
+    end
+  
+    @pond.allocated.should == {}
+    @pond.available.map(&:object_id).should == [oid2, oid1]
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: pond
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Hanks
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-02-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.14"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id004 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A simple, generic, thread-safe pool for connections or whatever else
+email: 
+- christopher.m.hanks@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pond.rb
+- lib/pond/version.rb
+- pond.gemspec
+- spec/checkout_spec.rb
+- spec/config_spec.rb
+- spec/spec_helper.rb
+- spec/wrapper_spec.rb
+homepage: https://github.com/chanks/pond
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id004
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id004
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple, generic, thread-safe pool
+test_files: 
+- spec/checkout_spec.rb
+- spec/config_spec.rb
+- spec/spec_helper.rb
+- spec/wrapper_spec.rb