jettywrapper 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90d0380f37306e0ca328c5a86d1dd304c7141e65
-  data.tar.gz: 8ee2ed933249ff1a268575048a1d920040566e0e
+  metadata.gz: bd615b5894ae53105f6abfebb4631fb96d99530e
+  data.tar.gz: 67aa692a2180259b925218c854701a6077200e92
 SHA512:
-  metadata.gz: a6c80ca97aa9f89f0c76882557f957596735b2f48dd923960a8e5afc68ed47ecf1b1072385a2a56a1e4038d3f1437dbe37262301b352d3470fc5dcbcf944393a
-  data.tar.gz: 8d82e591a1cd4d1a70ad37f449e88ad55dcd79744815b23f457b2d525da5e246b56af77ddc517b450a7f63a1901420c6ae1fe0756ee4a5f76f12bbafd731b71f
+  metadata.gz: c1689a3e0d63505018f1824196872b179a83110adf2bb328e5e439d48f3eb60d3b9d7103fe876acd1e7ea53e3fb128160695111a7dae46a2ef641a42f59d4566
+  data.tar.gz: 65aa972099f95f6afb84101f425b7b1d0c1554f0b94687623e5616f1668f887b551f9f6cf41a4b22c77ee4af1693d8197a26cac6a75569e174510d5313715c06

data/.travis.yml

@@ -5,11 +5,13 @@ matrix:
     - rvm: 2.1
       gemfile: gemfiles/rails4.1.gemfile
     - rvm: 2.1
-      gemfile: gemfiles/rails4.2.beta.gemfile
+      gemfile: gemfiles/rails4.2.gemfile
     - rvm: 2.0
-      gemfile: gemfiles/rails4.1.gemfile
+      gemfile: gemfiles/rails4.2.gemfile
     - rvm: 1.9.3
       gemfile: gemfiles/rails4.1.gemfile
+    - rvm: jruby-19mode
+      gemfile: gemfiles/rails4.2.gemfile
 
 notifications:
   irc: "irc.freenode.org#projecthydra"

data/Gemfile

@@ -2,6 +2,4 @@ source "http://rubygems.org"
 
 gemspec path: File.expand_path('..', __FILE__)
 
-gem 'rcov', :platform => :mri_18
-gem 'simplecov', :platform => :mri_19
-gem 'simplecov-rcov', :platform => :mri_19
+gem 'simplecov'

data/gemfiles/{rails4.2.beta.gemfile → rails4.2.gemfile}

@@ -7,4 +7,4 @@ if File.exists?(file)
   instance_eval File.read(file)
 end
 
-gem 'activesupport', '~> 4.2.0.beta2'
+gem 'activesupport', '~> 4.2.0'

data/jettywrapper.gemspec

@@ -16,20 +16,19 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")
   s.require_paths = ["lib"]
   s.license       = 'APACHE2'
-  
+
   s.required_rubygems_version = ">= 1.3.6"
-  
+
   s.add_dependency "logger"
   s.add_dependency "childprocess"
   s.add_dependency "i18n"
   s.add_dependency "activesupport", ">=3.0.0"
-  
-  s.add_development_dependency "rspec", '~> 2.99'
+  s.add_dependency 'rubyzip'
+
+  s.add_development_dependency "rspec", '~> 3.2'
   s.add_development_dependency "rspec-its"
   s.add_development_dependency 'rake'
-  
-  s.add_development_dependency 'yard'#, '0.6.5'  # Yard > 0.6.5 won't generate docs.
-                                                # I don't know why & don't have time to 
-                                                # debug it right now
+
+  s.add_development_dependency 'yard'
 end
 

data/lib/jettywrapper.rb

@@ -9,6 +9,8 @@ require 'active_support/core_ext/hash'
 require 'erb'
 require 'yaml'
 require 'logger'
+require 'open-uri'
+require 'zip'
 
 Dir[File.expand_path(File.join(File.dirname(__FILE__),"tasks/*.rake"))].each { |ext| load ext } if defined?(Rake)
 
@@ -32,6 +34,7 @@ class Jettywrapper
     self.base_path = self.class.app_root
   end
 
+
   # Methods inside of the class << self block can be called directly on Jettywrapper, as class methods.
   # Methods outside the class << self block must be called on Jettywrapper.instance, as instance methods.
   class << self
@@ -64,24 +67,43 @@ class Jettywrapper
       self.url = url if url
       logger.info "Downloading jetty at #{self.url} ..."
       FileUtils.mkdir tmp_dir unless File.exists? tmp_dir
-      system "curl -L #{self.url} -o #{zip_file}"
-      abort "Unable to download jetty from #{self.url}" unless $?.success?
+
+      begin
+        open(self.url) do |io|
+          IO.copy_stream(io,zip_file)
+        end
+      rescue Exception => e
+        abort "Unable to download jetty from #{self.url} #{e.message}"
+      end
     end
 
     def unzip
       download unless File.exists? zip_file
       logger.info "Unpacking #{zip_file}..."
       tmp_save_dir = File.join tmp_dir, 'jetty_generator'
-      system "unzip -d #{tmp_save_dir} -qo #{zip_file}"
-      abort "Unable to unzip #{zip_file} into tmp_save_dir/" unless $?.success?
+      begin
+        Zip::File.open(zip_file) do |zip_file|
+          # Handle entries one by one
+          zip_file.each do |entry|
+            dest_file = File.join(tmp_save_dir,entry.name)
+            FileUtils.remove_entry(dest_file,true)
+            entry.extract(dest_file)
+          end
+        end
+      rescue Exception => e
+        abort "Unable to unzip #{zip_file} into tmp_save_dir/ #{e.message}"
+      end
 
       # Remove the old jetty directory if it exists
-      system "rm -r #{jetty_dir}" if File.directory?(jetty_dir)
+      FileUtils.remove_dir(jetty_dir,true)
 
       # Move the expanded zip file into the final destination.
       expanded_dir = expanded_zip_dir(tmp_save_dir)
-      system "mv #{expanded_dir} #{jetty_dir}"
-      abort "Unable to move #{expanded_dir} into #{jetty_dir}/" unless $?.success?
+      begin
+        FileUtils.mv(expanded_dir, jetty_dir)
+      rescue Exception => e
+        abort "Unable to move #{expanded_dir} into #{jetty_dir}/ #{e.message}"
+      end
     end
 
     def expanded_zip_dir(tmp_save_dir)
@@ -91,7 +113,7 @@ class Jettywrapper
     end
 
     def clean
-      system "rm -rf #{jetty_dir}"
+      FileUtils.remove_dir(jetty_dir,true)
       unzip
     end
 

data/lib/jettywrapper/version.rb

@@ -1,3 +1,3 @@
 class Jettywrapper
-  VERSION = "2.0.0"
+  VERSION = "2.0.2"
 end

data/spec/lib/jettywrapper_integration_spec.rb

@@ -26,12 +26,12 @@ module Hydra
         ts.start      
         ts.logger.debug "Jetty started from rspec at #{ts.pid}"
         pid_from_file = File.open( ts.pid_path ) { |f| f.gets.to_i }
-        ts.pid.should eql(pid_from_file)
+        expect(ts.pid).to eql(pid_from_file)
       
         # Can we connect to solr?
         require 'net/http' 
         response = Net::HTTP.get_response(URI.parse("http://localhost:#{jetty_params[:jetty_port]}/solr/"))
-        response.code.should eql("200")
+        expect(response.code).to eql("200")
         ts.stop
       
       end
@@ -50,8 +50,8 @@ module Hydra
         ts.start
         ts.logger.debug "Jetty started from rspec at #{ts.pid}"
         response = Net::HTTP.get_response(URI.parse("http://localhost:#{jetty_params[:jetty_port]}/solr/"))
-        response.code.should eql("200")
-        lambda { ts.start }.should raise_exception(/Server is already running/)
+        expect(response.code).to eql("200")
+        expect { ts.start }.to raise_exception(/Server is already running/)
         ts.stop
       end
       
@@ -64,11 +64,11 @@ module Hydra
             @s.close
           end
           it "can check to see whether a port is already in use" do
-            Jettywrapper.is_port_in_use?(TEST_JETTY_PORTS.last).should eql(true)
+            expect(Jettywrapper.is_port_in_use?(TEST_JETTY_PORTS.last)).to eql(true)
           end
         end
         it "should be false when nothing is running" do
-          Jettywrapper.is_port_in_use?(TEST_JETTY_PORTS.last).should eql(false)
+          expect(Jettywrapper.is_port_in_use?(TEST_JETTY_PORTS.last)).to eql(false)
         end
       end
       
@@ -80,9 +80,9 @@ module Hydra
         }
         ts = Jettywrapper.configure(jetty_params) 
         ts.stop
-        ts.pid_file?.should eql(false)
+        expect(ts.pid_file?).to eql(false)
         ts.start
-        lambda{ ts.start }.should raise_exception
+        expect{ ts.start }.to raise_exception
         ts.stop
       end
 
@@ -96,8 +96,8 @@ module Hydra
         begin
           ts = Jettywrapper.configure(jetty_params) 
           ts.stop
-          ts.pid_file?.should eql(false)
-          lambda{ ts.start }.should raise_exception
+          expect(ts.pid_file?).to eql(false)
+          expect{ ts.start }.to raise_exception
           ts.stop
         ensure
           socket.close

data/spec/lib/jettywrapper_spec.rb

@@ -21,27 +21,27 @@ require 'fileutils'
 
     before do
       Jettywrapper.reset_config
+      FileUtils.rm "tmp/v8.1.1.zip", force: true
     end
 
     context "downloading" do
       context "with default file" do
         it "should download the zip file" do
-          FileUtils.rm "tmp/v8.1.1.zip", force: true
-          Jettywrapper.should_receive(:system).with('curl -L https://github.com/projecthydra/hydra-jetty/archive/v8.1.1.zip -o tmp/v8.1.1.zip').and_return(system ('true'))
+          expect(Jettywrapper).to receive(:open).with('https://github.com/projecthydra/hydra-jetty/archive/v8.1.1.zip').and_return(system ('true'))
           Jettywrapper.download
         end
       end
 
       context "specifying the file" do
         it "should download the zip file" do
-          Jettywrapper.should_receive(:system).with('curl -L http://example.co/file.zip -o tmp/file.zip').and_return(system ('true'))
+          expect(Jettywrapper).to receive(:open).with('http://example.co/file.zip').and_return(system ('true'))
           Jettywrapper.download('http://example.co/file.zip')
-          Jettywrapper.url.should == 'http://example.co/file.zip'
+          expect(Jettywrapper.url).to eq('http://example.co/file.zip')
         end
       end
       context "specifying the version" do
         it "should download the zip file" do
-          Jettywrapper.should_receive(:system).with('curl -L https://github.com/projecthydra/hydra-jetty/archive/v9.9.9.zip -o tmp/v9.9.9.zip').and_return(system ('true'))
+          expect(Jettywrapper).to receive(:open).with('https://github.com/projecthydra/hydra-jetty/archive/v9.9.9.zip').and_return(system ('true'))
           Jettywrapper.hydra_jetty_version = 'v9.9.9'
           Jettywrapper.download
         end
@@ -54,11 +54,11 @@ require 'fileutils'
       end
       context "with default file" do
         it "should download the zip file" do
-          File.should_receive(:exists?).and_return(true)
-          Jettywrapper.should_receive(:expanded_zip_dir).and_return('tmp/jetty_generator/hydra-jetty-v8.1.1')
-          Jettywrapper.should_receive(:system).with('unzip -d tmp/jetty_generator -qo tmp/v8.1.1.zip').and_return(system ('true'))
-          Jettywrapper.should_receive(:system).with('rm -r jetty').and_return(system ('true'))
-          Jettywrapper.should_receive(:system).with('mv tmp/jetty_generator/hydra-jetty-v8.1.1 jetty').and_return(system ('true'))
+          expect(File).to receive(:exists?).and_return(true)
+          expect(Jettywrapper).to receive(:expanded_zip_dir).and_return('tmp/jetty_generator/interal_dir')
+          expect(Zip::File).to receive(:open).with('tmp/v8.1.1.zip').and_return(true)
+          expect(FileUtils).to receive(:remove_dir).with('jetty',true).and_return(true)
+          expect(FileUtils).to receive(:mv).with('tmp/jetty_generator/interal_dir','jetty').and_return(true)
           Jettywrapper.unzip
         end
       end
@@ -68,11 +68,11 @@ require 'fileutils'
           Jettywrapper.url = 'http://example.co/file.zip'
         end
         it "should download the zip file" do
-          File.should_receive(:exists?).and_return(true)
-          Jettywrapper.should_receive(:expanded_zip_dir).and_return('tmp/jetty_generator/interal_dir')
-          Jettywrapper.should_receive(:system).with('unzip -d tmp/jetty_generator -qo tmp/file.zip').and_return(system ('true'))
-          Jettywrapper.should_receive(:system).with('rm -r jetty').and_return(system ('true'))
-          Jettywrapper.should_receive(:system).with('mv tmp/jetty_generator/interal_dir jetty').and_return(system ('true'))
+          expect(File).to receive(:exists?).and_return(true)
+          expect(Jettywrapper).to receive(:expanded_zip_dir).and_return('tmp/jetty_generator/interal_dir')
+          expect(Zip::File).to receive(:open).with('tmp/file.zip').and_return(true)
+          expect(FileUtils).to receive(:remove_dir).with('jetty',true).and_return(true)
+          expect(FileUtils).to receive(:mv).with('tmp/jetty_generator/interal_dir','jetty').and_return(true)
           Jettywrapper.unzip
         end
       end
@@ -187,6 +187,7 @@ require 'fileutils'
       it "should be the Rails environment" do
         Rails = double(env: 'test')
         expect(Jettywrapper.env).to eq "test"
+        Rails = nil
       end
 
       it "should use the ENV['RAILS_ENV']" do
@@ -210,58 +211,58 @@ require 'fileutils'
       before do
       end
       it "loads the application jetty.yml first" do
-        IO.should_receive(:read).with('./config/jetty.yml').and_return("default:\n")
+        expect(IO).to receive(:read).with('./config/jetty.yml').and_return("default:\n")
         config = Jettywrapper.load_config
       end
 
       it "loads the application jetty.yml using erb parsing" do
-        IO.should_receive(:read).with('./config/jetty.yml').and_return("default:\n  a: <%= 123 %>")
+        expect(IO).to receive(:read).with('./config/jetty.yml').and_return("default:\n  a: <%= 123 %>")
         config = Jettywrapper.load_config
         config[:a] == 123
       end
 
       it "falls back on the distributed jetty.yml" do
-        File.should_receive(:exists?).with('./config/jetty.yml').and_return(false)
-        IO.should_receive(:read).with { |value| value =~ /jetty.yml/ }.and_return("default:\n")
+        expect(File).to receive(:exists?).with('./config/jetty.yml').and_return(false)
+        expect(IO).to receive(:read).with(/jetty.yml/).and_return("default:\n")
         config = Jettywrapper.load_config
       end
 
       it "supports per-environment configuration" do
         ENV['environment'] = 'test'
-        IO.should_receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1\ntest:\n  a: 2")
+        expect(IO).to receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1\ntest:\n  a: 2")
         config = Jettywrapper.load_config
-        config[:a].should == 2
+        expect(config[:a]).to eq(2)
       end
 
       it "should take the env as an argument to load_config and the env should be sticky" do
-        IO.should_receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1\nfoo:\n  a: 2")
+        expect(IO).to receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1\nfoo:\n  a: 2")
         config = Jettywrapper.load_config('foo')
-        config[:a].should == 2
+        expect(config[:a]).to eq(2)
         expect(Jettywrapper.env).to eq 'foo'
       end
 
       it "falls back on a 'default' environment configuration" do
         ENV['environment'] = 'test'
-        IO.should_receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1")
+        expect(IO).to receive(:read).with('./config/jetty.yml').and_return("default:\n  a: 1")
         config = Jettywrapper.load_config
-        config[:a].should == 1
+        expect(config[:a]).to eq(1)
       end
     end
 
     context "instantiation" do
       it "can be instantiated" do
         ts = Jettywrapper.instance
-        ts.class.should eql(Jettywrapper)
+        expect(ts.class).to eql(Jettywrapper)
       end
 
       it "can be configured with a params hash" do
         ts = Jettywrapper.configure(@jetty_params)
-        ts.quiet.should == false
-        ts.jetty_home.should == "/path/to/jetty"
-        ts.port.should == @jetty_params[:jetty_port]
-        ts.solr_home.should == '/path/to/solr'
-        ts.startup_wait.should == 0
-        ts.jetty_opts.should == @jetty_params[:jetty_opts]
+        expect(ts.quiet).to eq(false)
+        expect(ts.jetty_home).to eq("/path/to/jetty")
+        expect(ts.port).to eq(@jetty_params[:jetty_port])
+        expect(ts.solr_home).to eq('/path/to/solr')
+        expect(ts.startup_wait).to eq(0)
+        expect(ts.jetty_opts).to eq(@jetty_params[:jetty_opts])
       end
 
       it "should override nil params with defaults" do
@@ -275,28 +276,28 @@ require 'fileutils'
         }
 
         ts = Jettywrapper.configure(jetty_params)
-        ts.quiet.should == true
-        ts.jetty_home.should == "/path/to/jetty"
-        ts.port.should == 8888
-        ts.solr_home.should == File.join(ts.jetty_home, "solr")
-        ts.startup_wait.should == 5
-        ts.jetty_opts.should == []
+        expect(ts.quiet).to eq(true)
+        expect(ts.jetty_home).to eq("/path/to/jetty")
+        expect(ts.port).to eq(8888)
+        expect(ts.solr_home).to eq(File.join(ts.jetty_home, "solr"))
+        expect(ts.startup_wait).to eq(5)
+        expect(ts.jetty_opts).to eq([])
       end
 
       it "passes all the expected values to jetty during startup" do
         ts = Jettywrapper.configure(@jetty_params)
         command = ts.jetty_command
-        command.should include("-Dsolr.solr.home=#{@jetty_params[:solr_home]}")
-        command.should include("-Djetty.port=#{@jetty_params[:jetty_port]}")
-        command.should include("-Xmx256m")
-        command.should include("start.jar")
-        command.slice(command.index('start.jar')+1, 2).should == @jetty_params[:jetty_opts]
+        expect(command).to include("-Dsolr.solr.home=#{@jetty_params[:solr_home]}")
+        expect(command).to include("-Djetty.port=#{@jetty_params[:jetty_port]}")
+        expect(command).to include("-Xmx256m")
+        expect(command).to include("start.jar")
+        expect(command.slice(command.index('start.jar')+1, 2)).to eq(@jetty_params[:jetty_opts])
       end
 
       it "escapes the :solr_home parameter" do
         ts = Jettywrapper.configure(@jetty_params.merge(:solr_home => '/path with spaces/to/solr'))
         command = ts.jetty_command
-        command.should include("-Dsolr.solr.home=/path\\ with\\ spaces/to/solr")
+        expect(command).to include("-Dsolr.solr.home=/path\\ with\\ spaces/to/solr")
       end
 
       it "has a pid if it has been started" do
@@ -304,10 +305,10 @@ require 'fileutils'
           :jetty_home => '/tmp'
         }
         ts = Jettywrapper.configure(jetty_params)
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>5454))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>5454))
         ts.stop
         ts.start
-        ts.pid.should eql(5454)
+        expect(ts.pid).to eql(5454)
         ts.stop
       end
 
@@ -317,37 +318,37 @@ require 'fileutils'
         }
         ts = Jettywrapper.configure(jetty_params)
         ts.stop
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>2323))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>2323))
         swp = Jettywrapper.start(jetty_params)
-        swp.pid.should eql(2323)
-        swp.pid_file.should eql("_tmp_test.pid")
+        expect(swp.pid).to eql(2323)
+        expect(swp.pid_file).to eql("_tmp_test.pid")
         swp.stop
       end
 
       it "can get the status for a given jetty instance" do
         # Don't actually start jetty, just fake it
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>12345))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>12345))
 
         jetty_params = {
           :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty")
         }
         Jettywrapper.stop(jetty_params)
-        Jettywrapper.is_jetty_running?(jetty_params).should eql(false)
+        expect(Jettywrapper.is_jetty_running?(jetty_params)).to eql(false)
         Jettywrapper.start(jetty_params)
-        Jettywrapper.is_jetty_running?(jetty_params).should eql(true)
+        expect(Jettywrapper.is_jetty_running?(jetty_params)).to eql(true)
         Jettywrapper.stop(jetty_params)
       end
 
       it "can get the pid for a given jetty instance" do
         # Don't actually start jetty, just fake it
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>54321))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>54321))
         jetty_params = {
           :jetty_home => File.expand_path("#{File.dirname(__FILE__)}/../../jetty")
         }
         Jettywrapper.stop(jetty_params)
-        Jettywrapper.pid(jetty_params).should eql(nil)
+        expect(Jettywrapper.pid(jetty_params)).to eql(nil)
         Jettywrapper.start(jetty_params)
-        Jettywrapper.pid(jetty_params).should eql(54321)
+        expect(Jettywrapper.pid(jetty_params)).to eql(54321)
         Jettywrapper.stop(jetty_params)
       end
 
@@ -355,12 +356,12 @@ require 'fileutils'
         jetty_params = {
           :jetty_home => '/tmp', :jetty_port => 8777
         }
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>2323))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>2323))
         swp = Jettywrapper.start(jetty_params)
-        (File.file? swp.pid_path).should eql(true)
+        expect(File.file? swp.pid_path).to eql(true)
 
         swp = Jettywrapper.stop(jetty_params)
-        (File.file? swp.pid_path).should eql(false)
+        expect(File.file? swp.pid_path).to eql(false)
       end
 
       describe "creates a pid file" do
@@ -368,20 +369,20 @@ require 'fileutils'
         describe "when the environment isn't set" do
           before { ENV['environment'] = nil }
           it "should have the path and env in the name" do
-            ts.pid_file.should eql("_path_to_jetty_development.pid")
+            expect(ts.pid_file).to eql("_path_to_jetty_development.pid")
           end
         end
         describe "when the environment is set" do
           before { ENV['environment'] = 'test' }
           it "should have the path and env in the name" do
-            ts.pid_file.should eql("_path_to_jetty_test.pid")
+            expect(ts.pid_file).to eql("_path_to_jetty_test.pid")
           end
         end
       end
 
       it "knows where its pid file should be written" do
         ts = Jettywrapper.configure(@jetty_params)
-        ts.pid_dir.should eql(File.expand_path("#{ts.base_path}/tmp/pids"))
+        expect(ts.pid_dir).to eql(File.expand_path("#{ts.base_path}/tmp/pids"))
       end
 
       it "writes a pid to a file when it is started" do
@@ -389,14 +390,14 @@ require 'fileutils'
           :jetty_home => '/tmp'
         }
         ts = Jettywrapper.configure(jetty_params)
-        Jettywrapper.any_instance.stub(:process).and_return(double('proc', :start => nil, :pid=>2222))
+        allow_any_instance_of(Jettywrapper).to receive(:process).and_return(double('proc', :start => nil, :pid=>2222))
         ts.stop
-        ts.pid_file?.should eql(false)
+        expect(ts.pid_file?).to eql(false)
         ts.start
-        ts.pid.should eql(2222)
-        ts.pid_file?.should eql(true)
+        expect(ts.pid).to eql(2222)
+        expect(ts.pid_file?).to eql(true)
         pid_from_file = File.open( ts.pid_path ) { |f| f.gets.to_i }
-        pid_from_file.should eql(2222)
+        expect(pid_from_file).to eql(2222)
       end
 
     end # end of instantiation context
@@ -404,38 +405,38 @@ require 'fileutils'
     context "logging" do
       it "has a logger" do
         ts = Jettywrapper.configure(@jetty_params)
-        ts.logger.should be_kind_of(Logger)
+        expect(ts.logger).to be_kind_of(Logger)
       end
 
     end # end of logging context
 
     context "wrapping a task" do
       it "wraps another method" do
-        Jettywrapper.any_instance.stub(:start).and_return(true)
-        Jettywrapper.any_instance.stub(:stop).and_return(true)
+        allow_any_instance_of(Jettywrapper).to receive(:start).and_return(true)
+        allow_any_instance_of(Jettywrapper).to receive(:stop).and_return(true)
         error = Jettywrapper.wrap(@jetty_params) do
         end
-        error.should eql(false)
+        expect(error).to eql(false)
       end
 
       it "configures itself correctly when invoked via the wrap method" do
-        Jettywrapper.any_instance.stub(:start).and_return(true)
-        Jettywrapper.any_instance.stub(:stop).and_return(true)
+        allow_any_instance_of(Jettywrapper).to receive(:start).and_return(true)
+        allow_any_instance_of(Jettywrapper).to receive(:stop).and_return(true)
         error = Jettywrapper.wrap(@jetty_params) do
           ts = Jettywrapper.instance
-          ts.quiet.should == @jetty_params[:quiet]
-          ts.jetty_home.should == "/path/to/jetty"
-          ts.port.should == @jetty_params[:jetty_port]
-          ts.solr_home.should == "/path/to/solr"
-          ts.startup_wait.should == 0
+          expect(ts.quiet).to eq(@jetty_params[:quiet])
+          expect(ts.jetty_home).to eq("/path/to/jetty")
+          expect(ts.port).to eq(@jetty_params[:jetty_port])
+          expect(ts.solr_home).to eq("/path/to/solr")
+          expect(ts.startup_wait).to eq(0)
         end
-        error.should eql(false)
+        expect(error).to eql(false)
       end
 
       it "captures any errors produced" do
-        Jettywrapper.any_instance.stub(:start).and_return(true)
-        Jettywrapper.any_instance.stub(:stop).and_return(true)
-        Jettywrapper.instance.logger.should_receive(:error).with("*** Error starting jetty: this is an expected error message")
+        allow_any_instance_of(Jettywrapper).to receive(:start).and_return(true)
+        allow_any_instance_of(Jettywrapper).to receive(:stop).and_return(true)
+        expect(Jettywrapper.instance.logger).to receive(:error).with("*** Error starting jetty: this is an expected error message")
         expect { error = Jettywrapper.wrap(@jetty_params) do
           raise "this is an expected error message"
         end }.to raise_error "this is an expected error message"
@@ -447,15 +448,15 @@ require 'fileutils'
       it "inherits the current stderr/stdout in 'loud' mode" do
         ts = Jettywrapper.configure(@jetty_params.merge(:quiet => false))
         process = ts.process
-        process.io.stderr.should == $stderr
-        process.io.stdout.should == $stdout
+        expect(process.io.stderr).to eq($stderr)
+        expect(process.io.stdout).to eq($stdout)
       end
 
       it "redirect stderr/stdout to a log file in quiet mode" do
         ts = Jettywrapper.configure(@jetty_params.merge(:quiet => true))
         process = ts.process
-        process.io.stderr.should_not == $stderr
-        process.io.stdout.should_not == $stdout
+        expect(process.io.stderr).not_to eq($stderr)
+        expect(process.io.stdout).not_to eq($stdout)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jettywrapper
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Chris Beer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -68,20 +68,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -145,7 +159,7 @@ files:
 - TODO.txt
 - config/jetty.yml
 - gemfiles/rails4.1.gemfile
-- gemfiles/rails4.2.beta.gemfile
+- gemfiles/rails4.2.gemfile
 - jettywrapper.gemspec
 - lib/jettywrapper.rb
 - lib/jettywrapper/version.rb
@@ -174,8 +188,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Convenience tasks for working with jetty from within a ruby project.
 test_files: []
+has_rdoc: