zk 0.8.6 → 0.8.7

data/.dotfiles/rvmrc

@@ -1 +1 @@
-rvm jruby-1.6.5@zk --create
+rvm jruby-1.6.7@zk --create

data/Gemfile

@@ -1,15 +1,9 @@
+# this is here for doing internal builds in our environment
+source ENV['MBOX_BUNDLER_SOURCE'] if ENV['MBOX_BUNDLER_SOURCE']
 source "http://rubygems.org"
-source "http://rubygems"
-source "http://localhost:50000"
 
 # Specify your gem's dependencies in zk.gemspec
 gemspec
 
-gem 'ruby-debug',   :platforms => [:mri_18, :jruby]
-
-if RUBY_VERSION < '1.9.3'
-  gem 'ruby-debug19', :platforms => :mri_19
-end
-
 
 # vim:ft=ruby

data/Rakefile

@@ -1,13 +1,28 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+# require 'rubygems'
+# gem 'rdoc', '~> 2.5'
+# require 'rdoc/task'
 
-require 'rubygems'
-gem 'rdoc', '~> 2.5'
-require 'rdoc/task'
+# RDoc::Task.new do |rd|
+#   rd.title = 'ZK Documentation'
+#   rd.rdoc_files.include("lib/**/*.rb")
+# end
 
-RDoc::Task.new do |rd|
-  rd.title = 'ZK Documentation'
-  rd.rdoc_files.include("lib/**/*.rb")
-end
+gemset_name = 'zk'
+
+%w[1.9.3 jruby].each do |rvm_ruby|
+  ruby_with_gemset = "#{rvm_ruby}@#{gemset_name}"
+  bundle_task_name  = "mb:#{rvm_ruby}:bundle_install"
+  rspec_task_name   = "mb:#{rvm_ruby}:run_rspec"
+
+  task bundle_task_name do
+    rm_f 'Gemfile.lock'
+    sh "rvm #{ruby_with_gemset} do bundle install"
+  end
 
+  task rspec_task_name => bundle_task_name do
+    sh "rvm #{ruby_with_gemset} do bundle exec rspec spec --fail-fast"
+  end
+
+  task "mb:test_all_rubies" => rspec_task_name
+end
 

data/lib/z_k/locker.rb

@@ -1,12 +1,11 @@
 module ZK
-  # Implements locking primitives {described here}[http://hadoop.apache.org/zookeeper/docs/current/recipes.html#sc_recipes_Locks]
+  # Implements locking primitives [described here](http://hadoop.apache.org/zookeeper/docs/current/recipes.html#sc_recipes_Locks)
   #
   # There are both shared and exclusive lock implementations.
   #
-  #
-  # NOTE: These locks are _not_ safe for use across threads. If you want to use
-  # the same Locker class between threads, it is your responsibility to
-  # synchronize operations.
+  # NOTE: These lock instances are _not_ safe for use across threads. If you
+  # want to use the same Locker instance between threads, it is your
+  # responsibility to synchronize operations.
   #
   module Locker
     SHARED_LOCK_PREFIX  = 'sh'.freeze

data/lib/z_k/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "0.8.6"
+  VERSION = "0.8.7"
 end

data/spec/z_k/locker_spec.rb

@@ -74,313 +74,352 @@ describe 'ZK::Client#locker' do
   end
 end
 
-describe ZK::Locker do
+shared_examples_for 'SharedLocker' do
   before do
-    @zk = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
-    @zk2 = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
-    @zk3 = ZK.new("localhost:#{ZK_TEST_PORT}")
-    @connections = [@zk, @zk2, @zk3]
-
-    wait_until{ @connections.all? {|c| c.connected?} }
-
-    @path = "shlock"
-    @root_lock_path = "/_zklocking/#{@path}"
+    @shared_locker  = ZK::Locker.shared_locker(zk, path)
+    @shared_locker2 = ZK::Locker.shared_locker(zk2, path)
   end
 
-  after do
-    @connections.each { |c| c.close! }
-    wait_until { @connections.all? { |c| !c.connected? } }
-  end
+  describe :lock! do
+    describe 'non-blocking success' do
+      before do
+        @rval   = @shared_locker.lock!
+        @rval2  = @shared_locker2.lock!
+      end
 
+      it %[should acquire the first lock] do
+        @rval.should be_true
+        @shared_locker.should be_locked
+      end
 
-  describe :SharedLocker do
-    before do
-      @shared_locker  = ZK::Locker.shared_locker(@zk, @path)
-      @shared_locker2 = ZK::Locker.shared_locker(@zk2, @path)
+      it %[should acquire the second lock] do
+        @rval2.should be_true
+        @shared_locker2.should be_locked
+      end
     end
 
-    describe :lock! do
-      describe 'non-blocking success' do
-        before do
-          @rval   = @shared_locker.lock!
-          @rval2  = @shared_locker2.lock!
-        end
+    describe 'non-blocking failure' do
+      before do
+        zk.mkdir_p(root_lock_path)
+        @write_lock_path = zk.create("#{root_lock_path}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
+        @rval = @shared_locker.lock!
+      end
 
-        it %[should acquire the first lock] do
-          @rval.should be_true
-          @shared_locker.should be_locked
-        end
+      after do
+        zk.rm_rf('/_zklocking')
+      end
 
-        it %[should acquire the second lock] do
-          @rval2.should be_true
-          @shared_locker2.should be_locked
-        end
+      it %[should return false] do
+        @rval.should be_false
       end
 
-      describe 'non-blocking failure' do
-        before do
-          @zk.mkdir_p(@root_lock_path)
-          @write_lock_path = @zk.create("#{@root_lock_path}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
-          @rval = @shared_locker.lock!
-        end
+      it %[should not be locked] do
+        @shared_locker.should_not be_locked
+      end
+    end
 
-        after do
-          @zk.rm_rf('/_zklocking')
-        end
+    describe 'blocking success' do
+      before do
+        zk.mkdir_p(root_lock_path)
+        @write_lock_path = zk.create("#{root_lock_path}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
+        $stderr.sync = true
+      end
 
-        it %[should return false] do
-          @rval.should be_false
-        end
+      it %[should acquire the lock after the write lock is released] do
+        ary = []
 
-        it %[should not be locked] do
-          @shared_locker.should_not be_locked
-        end
-      end
+        @shared_locker.lock!.should be_false
 
-      describe 'blocking success' do
-        before do
-          @zk.mkdir_p(@root_lock_path)
-          @write_lock_path = @zk.create("#{@root_lock_path}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
-          $stderr.sync = true
+        th = Thread.new do
+          @shared_locker.lock!(true)
+          ary << :locked
         end
 
-        it %[should acquire the lock after the write lock is released] do
-          ary = []
+        ary.should be_empty
+        @shared_locker.should_not be_locked
 
-          @shared_locker.lock!.should be_false
+        zk.delete(@write_lock_path)
 
-          th = Thread.new do
-            @shared_locker.lock!(true)
-            ary << :locked
-          end
+        th.join(2)
 
-          ary.should be_empty
-          @shared_locker.should_not be_locked
+        wait_until(2) { !ary.empty? }
+        ary.length.should == 1
 
-          @zk.delete(@write_lock_path)
+        @shared_locker.should be_locked
+      end
+    end
+  end
+end   # SharedLocker
 
-          th.join(2)
+shared_examples_for 'ExclusiveLocker' do
+  before do
+    @ex_locker = ZK::Locker.exclusive_locker(zk, path)
+    @ex_locker2 = ZK::Locker.exclusive_locker(zk2, path)
+  end
 
-          wait_until(2) { !ary.empty? }
-          ary.length.should == 1
+  describe :lock! do
+    describe 'non-blocking' do
+      before do
+        @rval = @ex_locker.lock!
+        @rval2 = @ex_locker2.lock!
+      end
 
-          @shared_locker.should be_locked
-        end
+      it %[should acquire the first lock] do
+        @rval.should be_true
       end
-    end
-  end   # SharedLocker
 
-  describe :ExclusiveLocker do
-    before do
-      @ex_locker = ZK::Locker.exclusive_locker(@zk, @path)
-      @ex_locker2 = ZK::Locker.exclusive_locker(@zk2, @path)
+      it %[should not acquire the second lock] do
+        @rval2.should be_false
+      end
+
+      it %[should acquire the second lock after the first lock is released] do
+        @ex_locker.unlock!.should be_true
+        @ex_locker2.lock!.should be_true
+      end
     end
 
-    describe :lock! do
-      describe 'non-blocking' do
-        before do
-          @rval = @ex_locker.lock!
-          @rval2 = @ex_locker2.lock!
-        end
+    describe 'blocking' do
+      before do
+        zk.mkdir_p(root_lock_path)
+        @read_lock_path = zk.create('/_zklocking/shlock/read', '', :mode => :ephemeral_sequential)
+      end
 
-        it %[should acquire the first lock] do
-          @rval.should be_true
-        end
+      it %[should block waiting for the lock] do
+        ary = []
+
+        @ex_locker.lock!.should be_false
 
-        it %[should not acquire the second lock] do
-          @rval2.should be_false
+        th = Thread.new do
+          @ex_locker.lock!(true)
+          ary << :locked
         end
 
-        it %[should acquire the second lock after the first lock is released] do
-          @ex_locker.unlock!.should be_true
-          @ex_locker2.lock!.should be_true
+        th.run
+      
+        ary.should be_empty
+        @ex_locker.should_not be_locked
+
+        zk.delete(@read_lock_path)
+
+        th.join(2)
+
+        ary.length.should == 1
+        @ex_locker.should be_locked
+      end
+    end
+  end
+end # ExclusiveLocker
+
+shared_examples_for 'shared-exclusive interaction' do
+  before do
+    @sh_lock = ZK::Locker.shared_locker(zk, path)
+    @ex_lock = ZK::Locker.exclusive_locker(zk2, path)
+  end
+
+  describe 'shared lock acquired first' do
+    it %[should block exclusive locks from acquiring until released] do
+      q1 = Queue.new
+      q2 = Queue.new
+
+      th1 = Thread.new do
+        @sh_lock.with_lock do
+          q1.enq(:got_lock)
+          Thread.current[:got_lock] = true
+          q2.pop
         end
       end
 
-      describe 'blocking' do
-        before do
-          @zk.mkdir_p(@root_lock_path)
-          @read_lock_path = @zk.create('/_zklocking/shlock/read', '', :mode => :ephemeral_sequential)
+      th2 = Thread.new do
+        q1.pop # wait for th1 to get the shared lock
+
+        Thread.current[:acquiring_lock] = true
+
+        @ex_lock.with_lock do
+          Thread.current[:got_lock] = true
         end
+      end
 
-        it %[should block waiting for the lock] do
-          ary = []
+      th1.join_until { th1[:got_lock] }
+      th1[:got_lock].should be_true
 
-          @ex_locker.lock!.should be_false
+      th2.join_until { th2[:acquiring_lock] }
+      th2[:acquiring_lock].should be_true
 
-          th = Thread.new do
-            @ex_locker.lock!(true)
-            ary << :locked
-          end
+      q2.num_waiting.should > 0
+      q2.enq(:release)
 
-          th.run
-        
-          ary.should be_empty
-          @ex_locker.should_not be_locked
+      th1.join_until { q2.size == 0 }
+      q2.size.should == 0
 
-          @zk.delete(@read_lock_path)
+      th1.join(2).should == th1
 
-          th.join(2)
+      th2.join_until { th2[:got_lock] }
+      th2[:got_lock].should be_true
 
-          ary.length.should == 1
-          @ex_locker.should be_locked
-        end
-      end
+      th2.join(2).should == th2
     end
-  end   # WriteLocker
+  end
 
-  describe 'read/write interaction' do
-    before do
-      @sh_lock = ZK::Locker.shared_locker(@zk, @path)
-      @ex_lock = ZK::Locker.exclusive_locker(@zk2, @path)
-    end
+  describe 'exclusive lock acquired first' do
+    it %[should block shared lock from acquiring until released] do
+      # same test as above but with the thread's locks switched, 
+      # th1 is the exclusive locker
+
+      q1 = Queue.new
+      q2 = Queue.new
 
-    describe 'shared lock acquired first' do
-      it %[should block exclusive locks from acquiring until released] do
-        q1 = Queue.new
-        q2 = Queue.new
-
-        th1 = Thread.new do
-          @sh_lock.with_lock do
-            q1.enq(:got_lock)
-            Thread.current[:got_lock] = true
-            q2.pop
-          end
+      th1 = Thread.new do
+        @ex_lock.with_lock do
+          q1.enq(:got_lock)
+          Thread.current[:got_lock] = true
+          q2.pop
         end
+      end
 
-        th2 = Thread.new do
-          q1.pop # wait for th1 to get the shared lock
+      th2 = Thread.new do
+        q1.pop # wait for th1 to get the shared lock
 
-          Thread.current[:acquiring_lock] = true
+        Thread.current[:acquiring_lock] = true
 
-          @ex_lock.with_lock do
-            Thread.current[:got_lock] = true
-          end
+        @sh_lock.with_lock do
+          Thread.current[:got_lock] = true
         end
+      end
 
-        th1.join_until { th1[:got_lock] }
-        th1[:got_lock].should be_true
+      th1.join_until { th1[:got_lock] }
+      th1[:got_lock].should be_true
 
-        th2.join_until { th2[:acquiring_lock] }
-        th2[:acquiring_lock].should be_true
+      th2.join_until { th2[:acquiring_lock] }
+      th2[:acquiring_lock].should be_true
 
-        q2.num_waiting.should > 0
-        q2.enq(:release)
+      q2.num_waiting.should > 0
+      q2.enq(:release)
 
-        th1.join_until { q2.size == 0 }
-        q2.size.should == 0
+      th1.join_until { q2.size == 0 }
+      q2.size.should == 0
 
-        th1.join(2).should == th1
+      th1.join(2).should == th1
 
-        th2.join_until { th2[:got_lock] }
-        th2[:got_lock].should be_true
+      th2.join_until { th2[:got_lock] }
+      th2[:got_lock].should be_true
 
-        th2.join(2).should == th2
-      end
+      th2.join(2).should == th2
+    end
+  end
+
+  describe 'shared-exclusive-shared' do
+    before do
+      zk3.should_not be_nil
+      @sh_lock2 = ZK::Locker.shared_locker(zk3, path) 
     end
 
-    describe 'exclusive lock acquired first' do
-      it %[should block shared lock from acquiring until released] do
-        # same test as above but with the thread's locks switched, 
-        # th1 is the exclusive locker
+    it %[should act something like a queue] do
+      @array = []
 
-        q1 = Queue.new
-        q2 = Queue.new
+      @sh_lock.lock!.should be_true
+      @sh_lock.should be_locked
 
-        th1 = Thread.new do
-          @ex_lock.with_lock do
-            q1.enq(:got_lock)
-            Thread.current[:got_lock] = true
-            q2.pop
-          end
+      ex_th = Thread.new do
+        begin
+          @ex_lock.lock!(true)  # blocking lock
+          Thread.current[:got_lock] = true
+          @array << :ex_lock
+        ensure
+          @ex_lock.unlock!
         end
+      end
 
-        th2 = Thread.new do
-          q1.pop # wait for th1 to get the shared lock
+      ex_th.join_until { @ex_lock.waiting? }
+      @ex_lock.should be_waiting
+      @ex_lock.should_not be_locked
+
+      # this is the important one, does the second shared lock get blocked by
+      # the exclusive lock
+      @sh_lock2.lock!.should_not be_true
+
+      sh2_th = Thread.new do
+        begin
+          @sh_lock2.lock!(true)
+          Thread.current[:got_lock] = true
+          @array << :sh_lock2
+        ensure
+          @sh_lock2.unlock!
+        end
+      end
 
-          Thread.current[:acquiring_lock] = true
+      sh2_th.join_until { @sh_lock2.waiting? }
+      @sh_lock2.should be_waiting
 
-          @sh_lock.with_lock do
-            Thread.current[:got_lock] = true
-          end
-        end
+      @sh_lock.unlock!.should be_true
 
-        th1.join_until { th1[:got_lock] }
-        th1[:got_lock].should be_true
+      ex_th.join_until { ex_th[:got_lock] }
+      ex_th[:got_lock].should be_true
 
-        th2.join_until { th2[:acquiring_lock] }
-        th2[:acquiring_lock].should be_true
+      sh2_th.join_until { sh2_th[:got_lock] }
+      sh2_th[:got_lock].should be_true
 
-        q2.num_waiting.should > 0
-        q2.enq(:release)
+      @array.length.should == 2
+      @array.should == [:ex_lock, :sh_lock2]
+    end
+  end
+end # shared-exclusive interaction
 
-        th1.join_until { q2.size == 0 }
-        q2.size.should == 0
 
-        th1.join(2).should == th1
+describe ZK::Locker do
+  let(:zk)  { ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default) }
+  let(:zk2) { ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default) }
+  let(:zk3) { ZK.new("localhost:#{ZK_TEST_PORT}") }
 
-        th2.join_until { th2[:got_lock] }
-        th2[:got_lock].should be_true
+  let(:connections) { [zk, zk2, zk3] }
 
-        th2.join(2).should == th2
-      end
-    end
+  let(:path) { "shlock" }
+  let(:root_lock_path) { "/_zklocking/#{path}" }
 
-    describe 'shared-exclusive-shared' do
-      before do
-        @zk3.should_not be_nil
-        @sh_lock2 = ZK::Locker.shared_locker(@zk3, @path) 
-      end
+  before do
+    wait_until{ connections.all?(&:connected?) }
+  end
+
+  after do
+    connections.each { |c| c.close! }
+    wait_until { !connections.any?(&:connected?) }
+  end
 
-      it %[should act something like a queue] do
-        @array = []
+  it_should_behave_like 'SharedLocker'
+  it_should_behave_like 'ExclusiveLocker'
+  it_should_behave_like 'shared-exclusive interaction'
+end # ZK::Locker
 
-        @sh_lock.lock!.should be_true
-        @sh_lock.should be_locked
+describe "ZK::Locker chrooted" do
+  let(:chroot_path) { '/_zk_chroot_' }
 
-        ex_th = Thread.new do
-          begin
-            @ex_lock.lock!(true)  # blocking lock
-            Thread.current[:got_lock] = true
-            @array << :ex_lock
-          ensure
-            @ex_lock.unlock!
-          end
-        end
+  let(:zk)  { ZK.new("localhost:#{ZK_TEST_PORT}#{chroot_path}") }
+  let(:zk2) { ZK.new("localhost:#{ZK_TEST_PORT}#{chroot_path}") }
+  let(:zk3) { ZK.new("localhost:#{ZK_TEST_PORT}#{chroot_path}") }
 
-        ex_th.join_until { @ex_lock.waiting? }
-        @ex_lock.should be_waiting
-        @ex_lock.should_not be_locked
-
-        # this is the important one, does the second shared lock get blocked by
-        # the exclusive lock
-        @sh_lock2.lock!.should_not be_true
-
-        sh2_th = Thread.new do
-          begin
-            @sh_lock2.lock!(true)
-            Thread.current[:got_lock] = true
-            @array << :sh_lock2
-          ensure
-            @sh_lock2.unlock!
-          end
-        end
+  let(:connections) { [zk, zk2, zk3] }
 
-        sh2_th.join_until { @sh_lock2.waiting? }
-        @sh_lock2.should be_waiting
+  let(:path) { "shlock" }
+  let(:root_lock_path) { "/_zklocking/#{path}" }
 
-        @sh_lock.unlock!.should be_true
+  before do
+    ZK.open("localhost:#{ZK_TEST_PORT}") do |zk|
+      zk.mkdir_p(chroot_path)
+    end
 
-        ex_th.join_until { ex_th[:got_lock] }
-        ex_th[:got_lock].should be_true
+    wait_until{ connections.all?(&:connected?) }
+  end
 
-        sh2_th.join_until { sh2_th[:got_lock] }
-        sh2_th[:got_lock].should be_true
+  after do
+    connections.each { |c| c.close! }
+    wait_until { !connections.any?(&:connected?) }
 
-        @array.length.should == 2
-        @array.should == [:ex_lock, :sh_lock2]
-      end
+    ZK.open("localhost:#{ZK_TEST_PORT}") do |zk|
+      zk.rm_rf(chroot_path)
     end
   end
+
+  it_should_behave_like 'SharedLocker'
+  it_should_behave_like 'ExclusiveLocker'
+  it_should_behave_like 'shared-exclusive interaction'
 end
 

data/zk.gemspec

@@ -8,16 +8,16 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Jonathan D. Simms", "Topper Bowers"]
   s.email       = ["simms@hp.com", "tobowers@hp.com"]
-  s.homepage    = ""
+  s.homepage    = "https://github.com/slyphon/zk"
   s.summary     = %q{A high-level wrapper around the zookeeper driver}
-  s.description = s.summary
+  s.description = s.summary + "\n"
 
-  s.add_runtime_dependency 'slyphon-zookeeper', '~> 0.2.8'
+  s.add_runtime_dependency 'slyphon-zookeeper', '~> 0.3.0'
 
-  s.add_development_dependency 'rspec', '~> 2.4.0'
-  s.add_development_dependency 'wirble'
+  s.add_development_dependency 'rspec', '~> 2.8.0'
   s.add_development_dependency 'flexmock', '~> 0.8.10'
   s.add_development_dependency 'ZenTest', '~> 4.5.0'
+  s.add_development_dependency 'pry'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 51
+  hash: 49
   prerelease: 
   segments: 
   - 0
   - 8
-  - 6
-  version: 0.8.6
+  - 7
+  version: 0.8.7
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-27 00:00:00 Z
+date: 2012-04-11 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: slyphon-zookeeper
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 19
         segments: 
         - 0
-        - 2
-        - 8
-        version: 0.2.8
+        - 3
+        - 0
+        version: 0.3.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,30 +42,32 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 47
         segments: 
         - 2
-        - 4
+        - 8
         - 0
-        version: 2.4.0
+        version: 2.8.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: wirble
+  name: flexmock
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 43
         segments: 
         - 0
-        version: "0"
+        - 8
+        - 10
+        version: 0.8.10
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: flexmock
+  name: ZenTest
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -74,29 +76,29 @@ dependencies:
       - !ruby/object:Gem::Version 
         hash: 43
         segments: 
+        - 4
+        - 5
         - 0
-        - 8
-        - 10
-        version: 0.8.10
+        version: 4.5.0
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: ZenTest
+  name: pry
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 3
         segments: 
-        - 4
-        - 5
         - 0
-        version: 4.5.0
+        version: "0"
   type: :development
   version_requirements: *id005
-description: A high-level wrapper around the zookeeper driver
+description: |
+  A high-level wrapper around the zookeeper driver
+
 email: 
 - simms@hp.com
 - tobowers@hp.com
@@ -153,7 +155,7 @@ files:
 - spec/z_k/threadpool_spec.rb
 - spec/zookeeper_spec.rb
 - zk.gemspec
-homepage: ""
+homepage: https://github.com/slyphon/zk
 licenses: []
 
 post_install_message: