rack-unreloader 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c8f1734dc2b5c882473017b36c57ebd8ec83ce9
-  data.tar.gz: 77139686abfd0970924657fd236717be42b70da5
+  metadata.gz: d9318a0edd80ea0c0bae830750c33a607ef0146a
+  data.tar.gz: d85653f1770a69dcde0e4c15dd32db9b43ff8686
 SHA512:
-  metadata.gz: 15eb8fac861e37af6c853b115ab64c38d0ec270273fb13a09f0aa72fc94fe5007b884541f6c5732de1146564342a8b69d05435f22fd076c2fdd842564ebf22b7
-  data.tar.gz: b43aad4ee73d6218cad149d523aaa1e1f086bb7020719b78ec7b14e028e4f8530fb4c8e90429a3463344737f4dc4d6332431eecbd6e13d4cbec911f836a00c8c
+  metadata.gz: ac585d0650959361e75a940f12b677062247ae88c9bc8811146e1808183abb907465ffc786dfffb98372ae9aaac4f5d578dd140d762c39b10ac9d76c51caf6f7
+  data.tar.gz: 299ffb392c1d525c8037855f353209669bf06fca106af0b745fda6b84175d3f60d8e2cc3e0de0e6e8ed22a5e22bf36756678d47015a7969f62b0c214a97a88ab

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 1.4.0 (2016-01-15)
+
+* Avoid use of Thread.exclusive, preventing warnings on ruby 2.3 (celsworth, jeremyevans) (#6)
+
 = 1.3.0 (2015-04-06)
 
 * Log when specified constant exists before loading file or does not exist after loading (jeremyevans)

data/README.rdoc

@@ -50,14 +50,14 @@ constants, as it will unload those constants first.  This is why the example
 code requires the +roda+ library normally before requiring +app.rb+ using
 <tt>Rack::Unreloader</tt>.
 
-However, if +app.rb+ requires more than a single file, it is more 
+However, if +app.rb+ requires more than a single file, it is more
 practical to tell <tt>Rack::Unreloader</tt> to only unload specific subclasses:
 
   require 'rack/unreloader'
   Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda'){App}
   Unreloader.require './app.rb'
   run Unreloader
-  
+
 When the +:subclasses+ option is given, only subclasses of the given classes
 will be unloaded before reloading the file.  It is recommended that
 you use a +:subclasses+ option when using <tt>Rack::Unreloader</tt>.
@@ -133,14 +133,14 @@ module or superclass.
 
 You can specify the file dependencies when using rack-unreloader:
 
-  Unreload.record_dependency('lib/module_file.rb', %w'models/mod1.rb models/mod2.rb')
+  Unreloader.record_dependency('lib/module_file.rb', %w'models/mod1.rb models/mod2.rb')
 
 If lib/module_file.rb is changed, rack-unreloader will reload models/mod1.rb
 and models/mod2.rb after reloading lib/module_file.rb.
 
 You can provide directories when requiring dependencies.  For example:
 
-  Unreload.record_dependency('helpers', %w'app.rb')
+  Unreloader.record_dependency('helpers', %w'app.rb')
 
 will make it so the addition of any ruby files to the helpers directory
 will trigger a reload of +app.rb+, and future changes to any of those files
@@ -149,7 +149,7 @@ in the helpers directory will also trigger a reload of +app.rb+.
 
 You can also use a directory as the second argument:
 
-  Unreload.record_dependency('mod.rb', 'models')
+  Unreloader.record_dependency('mod.rb', 'models')
 
 With this, any change to +mod.rb+ will trigger a reload of all ruby files in
 the models directory, even if such files are added later.

data/Rakefile

@@ -10,37 +10,13 @@ end
 
 ### Specs
 
-begin
-  begin
-    raise LoadError if ENV['RSPEC1']
-    # RSpec 2
-    require "rspec/core/rake_task"
-    spec_class = RSpec::Core::RakeTask
-    spec_files_meth = :pattern=
-  rescue LoadError
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-  end
-
-  spec = lambda do |name, files, d|
-    lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
-    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
-    desc d
-    spec_class.new(name) do |t|
-      t.send(spec_files_meth, files)
-    end
-  end
-
-  task :default => [:spec]
-  spec.call("spec", Dir["spec/*_spec.rb"], "Run specs")
-rescue LoadError
-  task :default do
-    puts "Must install rspec to run the default task (which runs specs)"
-  end
+desc "Run specs"
+task :spec do
+  sh "#{FileUtils::RUBY} -rubygems -I lib spec/unreloader_spec.rb"
 end
 
+task :default => :spec
+
 ### RDoc
 
 RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Rack::Unreloader: Reload application when files change, unloading constants first']

data/lib/rack/unreloader.rb

@@ -1,9 +1,13 @@
 require 'find'
+require 'monitor'
 
 module Rack
   # Reloading application that unloads constants before reloading the relevant
   # files, calling the new rack app if it gets reloaded.
   class Unreloader
+    # Mutex used to synchronize reloads
+    MUTEX = Monitor.new
+
     # Reference to ::File as File would return Rack::File by default.
     F = ::File
 
@@ -67,7 +71,7 @@ module Rack
     # Call the app with the environment.
     def call(env)
       if @cooldown && Time.now > @last + @cooldown
-        Thread.respond_to?(:exclusive) ? Thread.exclusive{reload!} : reload!
+        MUTEX.synchronize{reload!}
         @last = Time.now
       end
       @app_block.call.call(env)

data/spec/unreloader_spec.rb

@@ -1,15 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/rack/unreloader')
-
-if defined?(RSpec)
-  require 'rspec/version'
-  if RSpec::Version::STRING >= '2.11.0'
-    RSpec.configure do |config|
-      config.expect_with :rspec do |c|
-        c.syntax = :should
-      end
-    end
-  end
-end
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/hooks'
 
 module ModifiedAt
   def set_modified_time(file, time)
@@ -62,8 +54,8 @@ describe Rack::Unreloader do
   end
 
   def log_match(*logs)
-    @logger.length.should == logs.length
-    logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.should == l : log.should =~ l}
+    @logger.length.must_equal logs.length
+    logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.must_equal(l) : log.must_match(l)}
   end
 
   before do
@@ -80,26 +72,26 @@ describe Rack::Unreloader do
   end
 
   it "should not reload files automatically if cooldown option is nil" do
-    ru(:cooldown => nil).call({}).should == [1]
+    ru(:cooldown => nil).call({}).must_equal [1]
     update_app(code(2))
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     @ru.reload!
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
   end
 
   it "should not setup a reloader if reload option is false" do
     @filename = 'spec/app_no_reload.rb'
-    ru(:reload => false).call({}).should == [1]
+    ru(:reload => false).call({}).must_equal [1]
     file = 'spec/app_no_reload2.rb'
     File.open(file, 'wb'){|f| f.write('ANR2 = 2')}
     ru.require 'spec/app_no_*2.rb'
-    ANR2.should == 2
+    ANR2.must_equal 2
   end
 
   it "should unload constants contained in file and reload file if file changes" do
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app(code(2))
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -112,9 +104,9 @@ describe Rack::Unreloader do
     base_ru
     update_app(code(1))
     @ru.require(@filename){|f| :ObjectSpace}
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app(code(2))
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -124,12 +116,12 @@ describe Rack::Unreloader do
   end
 
   it "should pickup files added as dependencies" do
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
     update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 3; end", 'spec/app2.rb')
-    ru.call({}).should == [[2], [3]]
+    ru.call({}).must_equal [[2], [3]]
     update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
-    ru.call({}).should == [[2], [4]]
+    ru.call({}).must_equal [[2], [4]]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -146,12 +138,12 @@ describe Rack::Unreloader do
   end
 
   it "should support :subclasses option and only unload subclasses of given class" do
-    ru(:subclasses=>'App').call({}).should == [1]
+    ru(:subclasses=>'App').call({}).must_equal [1]
     update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
     update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 3; end", 'spec/app2.rb')
-    ru.call({}).should == [[1, 2], [3]]
+    ru.call({}).must_equal [[1, 2], [3]]
     update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
-    ru.call({}).should == [[1, 2], [4]]
+    ru.call({}).must_equal [[1, 2], [4]]
     update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -167,7 +159,7 @@ describe Rack::Unreloader do
   end
 
   it "should log invalid constant names in :subclasses options" do
-    ru(:subclasses=>%w'1 Object').call({}).should == [1]
+    ru(:subclasses=>%w'1 Object').call({}).must_equal [1]
     logger.uniq!
     log_match 'Invalid constant name: 1',
               %r{\ALoading.*spec/app\.rb\z},
@@ -175,9 +167,9 @@ describe Rack::Unreloader do
   end
 
   it "should unload modules before reloading similar to classes" do
-    ru(:code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    ru(:code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).must_equal [1]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -187,9 +179,9 @@ describe Rack::Unreloader do
   end
 
   it "should unload specific modules by name via :subclasses option" do
-    ru(:subclasses=>'App', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    ru(:subclasses=>'App', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).must_equal [1]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -199,21 +191,21 @@ describe Rack::Unreloader do
   end
 
   it "should not unload modules by name if :subclasses option used and module not present" do
-    ru(:subclasses=>'Foo', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    ru(:subclasses=>'Foo', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).must_equal [1]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
-    ru.call({}).should == [1, 2]
+    ru.call({}).must_equal [1, 2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\AUnloading.*spec/app\.rb\z},
               %r{\ALoading.*spec/app\.rb\z}
   end
 
   it "should unload partially loaded modules if loading fails, and allow future loading" do
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app("module App; def self.call(env) @a end; @a ||= []; raise 'foo'; end")
-    proc{ru.call({})}.should raise_error
-    defined?(::App).should == nil
+    proc{ru.call({})}.must_raise RuntimeError
+    defined?(::App).must_equal nil
     update_app(code(2))
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -226,9 +218,9 @@ describe Rack::Unreloader do
   end
 
   it "should unload classes in namespaces" do
-    ru(:code=>"class Array::App; def self.call(env) @a end; @a ||= []; @a << 1; end", :block=>proc{Array::App}).call({}).should == [1]
+    ru(:code=>"class Array::App; def self.call(env) @a end; @a ||= []; @a << 1; end", :block=>proc{Array::App}).call({}).must_equal [1]
     update_app("class Array::App; def self.call(env) @a end; @a ||= []; @a << 2; end")
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: Array::App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -242,11 +234,11 @@ describe Rack::Unreloader do
     update_app("class App; def self.call(env) @a end; @a ||= []; @a << 2; RU.require 'spec/app2.rb'; end")
     update_app("class App; @a << 3 end", 'spec/app2.rb')
     @ru.require 'spec/app.rb'
-    ru.call({}).should == [2, 3]
+    ru.call({}).must_equal [2, 3]
     update_app("class App; @a << 4 end", 'spec/app2.rb')
-    ru.call({}).should == [2, 3, 4]
+    ru.call({}).must_equal [2, 3, 4]
     update_app("class App; def self.call(env) @a end; @a ||= []; @a << 2; RU.require 'spec/app2.rb'; end")
-    ru.call({}).should == [2, 4]
+    ru.call({}).must_equal [2, 4]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ALoading.*spec/app2\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
@@ -266,9 +258,9 @@ describe Rack::Unreloader do
     base_ru
     update_app("class App; def self.call(env) [@a, App2.a] end; @a ||= []; @a << 1; end; class App2; def self.a; @a end; @a ||= []; @a << 2; end")
     @ru.require('spec/app.rb'){|f| File.basename(f).sub(/\.rb/, '').capitalize}
-    ru.call({}).should == [[1], [2]]
+    ru.call({}).must_equal [[1], [2]]
     update_app("class App; def self.call(env) [@a, App2.a] end; @a ||= []; @a << 3; end; class App2; def self.a; @a end; @a ||= []; @a << 4; end")
-    ru.call({}).should == [[3], [2, 4]]
+    ru.call({}).must_equal [[3], [2, 4]]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -281,9 +273,9 @@ describe Rack::Unreloader do
     base_ru(:block=>proc{$app})
     update_app("$app = Class.new do def self.call(env) @a end; @a ||= []; @a << 1; end")
     @ru.require('spec/app.rb')
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app("$app = Class.new do def self.call(env) @a end; @a ||= []; @a << 2; end")
-    ru.call({}).should == [2]
+    ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\AUnloading.*spec/app\.rb\z},
               %r{\ALoading.*spec/app\.rb\z}
@@ -293,9 +285,9 @@ describe Rack::Unreloader do
     base_ru
     update_app(code(1))
     @ru.require('spec/app.rb'){|f| 'Foo'}
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     update_app(code(2))
-    ru.call({}).should == [1, 2]
+    ru.call({}).must_equal [1, 2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\AConstants not defined after loading .*spec/app\.rb: Foo\z},
               %r{\AUnloading.*spec/app\.rb\z},
@@ -309,7 +301,7 @@ describe Rack::Unreloader do
     update_app(code(1))
     ::App2 = 1
     @ru.require('spec/app.rb'){|f| 'App2'}
-    ru.call({}).should == [1]
+    ru.call({}).must_equal [1]
     log_match %r{\AConstants already defined before loading .*spec/app\.rb: App2\z},
               %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App2\z}
@@ -322,19 +314,21 @@ describe Rack::Unreloader do
     ru.require 'spec/app_mod.rb'
     ru.require 'spec/app.rb'
     ru.record_dependency 'spec/app_mod.rb', 'spec/app.rb'
-    ru.call({}).should == 1
+    ru.call({}).must_equal 1
     update_app("module A; B = 2; end", 'spec/app_mod.rb')
-    ru.call({}).should == 2
+    ru.call({}).must_equal 2
     update_app("module A; include C; end", 'spec/app_mod.rb')
     update_app("module C; B = 3; end", 'spec/app_mod2.rb')
     ru.record_dependency 'spec/app_mod2.rb', 'spec/app_mod.rb'
     ru.require 'spec/app_mod2.rb'
-    ru.call({}).should == 3
+    ru.call({}).must_equal 3
     update_app("module C; B = 4; end", 'spec/app_mod2.rb')
-    ru.call({}).should == 4
+    ru.call({}).must_equal 4
   end
 
   describe "with a directory" do
+    include Minitest::Hooks
+
     before(:all) do
       Dir.mkdir('spec/dir')
       Dir.mkdir('spec/dir/subdir')
@@ -356,7 +350,7 @@ describe Rack::Unreloader do
       File.open(file, 'wb'){|f| f.write('ANR3 = 3')}
       base_ru(:reload => false)
       ru.require 'spec/dir'
-      ANR3.should == 3
+      ANR3.must_equal 3
     end
 
     it "should handle recorded dependencies in directories" do
@@ -366,16 +360,16 @@ describe Rack::Unreloader do
       ru.require 'spec/dir/subdir'
       ru.require 'spec/app.rb'
       ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
-      ru.call({}).should == 1
+      ru.call({}).must_equal 1
       update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
-      ru.call({}).should == 2
+      ru.call({}).must_equal 2
       update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
       update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
       ru.require 'spec/dir/subdir2/app_mod2.rb'
       ru.record_dependency 'spec/dir/subdir2/app_mod2.rb', 'spec/dir/subdir'
-      ru.call({}).should == 3
+      ru.call({}).must_equal 3
       update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
-      ru.call({}).should == 4
+      ru.call({}).must_equal 4
     end
 
     it "should handle recorded dependencies in directories when files are added or removed later" do
@@ -386,19 +380,19 @@ describe Rack::Unreloader do
       ru.require 'spec/app.rb'
       ru.require 'spec/dir/subdir'
       ru.require 'spec/dir/subdir2'
-      ru.call({}).should == 0
+      ru.call({}).must_equal 0
       update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
-      ru.call({}).should == 1
+      ru.call({}).must_equal 1
       update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
-      ru.call({}).should == 2
+      ru.call({}).must_equal 2
       update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
-      ru.call({}).should == 2
+      ru.call({}).must_equal 2
       update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
-      ru.call({}).should == 3
+      ru.call({}).must_equal 3
       update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
-      ru.call({}).should == 4
+      ru.call({}).must_equal 4
       File.delete 'spec/dir/subdir/app_mod.rb'
-      ru.call({}).should == 0
+      ru.call({}).must_equal 0
     end
 
     it "should handle classes split into multiple files" do
@@ -406,20 +400,20 @@ describe Rack::Unreloader do
       update_app("class App; RU.require('spec/dir'); def self.call(env) \"\#{a if respond_to?(:a)}\#{b if respond_to?(:b)}1\".to_i end; end")
       ru.require 'spec/app.rb'
       ru.record_split_class 'spec/app.rb', 'spec/dir'
-      ru.call({}).should == 1
+      ru.call({}).must_equal 1
       update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
-      ru.call({}).should == 21
+      ru.call({}).must_equal 21
       update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
-      ru.call({}).should == 31
+      ru.call({}).must_equal 31
       update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
-      ru.call({}).should == 341
+      ru.call({}).must_equal 341
       update_app("class App; def self.a; 5 end end", 'spec/dir/appa.rb')
       update_app("class App; def self.b; 6 end end", 'spec/dir/appb.rb')
-      ru.call({}).should == 561
+      ru.call({}).must_equal 561
       update_app("class App; end", 'spec/dir/appa.rb')
-      ru.call({}).should == 61
+      ru.call({}).must_equal 61
       File.delete 'spec/dir/appb.rb'
-      ru.call({}).should == 1
+      ru.call({}).must_equal 1
     end
 
     it "should pick up changes to files in that directory" do
@@ -427,9 +421,9 @@ describe Rack::Unreloader do
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       update_app("App.call[:foo] = 1", 'spec/dir/a.rb')
       @ru.require('spec/app.rb')
-      ru.call({}).should == {:foo=>1}
+      ru.call({}).must_equal(:foo=>1)
       update_app("App.call[:foo] = 2", 'spec/dir/a.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ALoading.*spec/dir/a\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},
@@ -443,9 +437,9 @@ describe Rack::Unreloader do
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       update_app("App.call[:foo] = 1", 'spec/dir/subdir/a.rb')
       @ru.require('spec/app.rb')
-      ru.call({}).should == {:foo=>1}
+      ru.call({}).must_equal(:foo=>1)
       update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ALoading.*spec/dir/subdir/a\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},
@@ -458,9 +452,9 @@ describe Rack::Unreloader do
       base_ru
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       @ru.require('spec/app.rb')
-      ru.call({}).should == {}
+      ru.call({}).must_equal({})
       update_app("App.call[:foo] = 2", 'spec/dir/a.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},
                 %r{\ALoading.*spec/dir/a\.rb\z}
@@ -470,9 +464,9 @@ describe Rack::Unreloader do
       base_ru
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       @ru.require('spec/app.rb')
-      ru.call({}).should == {}
+      ru.call({}).must_equal({})
       update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},
                 %r{\ALoading.*spec/dir/subdir/a\.rb\z}
@@ -483,10 +477,10 @@ describe Rack::Unreloader do
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       update_app("App.call[:foo] = 1", 'spec/dir/a.rb')
       @ru.require('spec/app.rb')
-      ru.call({}).should == {:foo=>1}
+      ru.call({}).must_equal(:foo=>1)
       File.delete('spec/dir/a.rb')
       update_app("App.call[:foo] = 2", 'spec/dir/b.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ALoading.*spec/dir/a\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},
@@ -500,10 +494,10 @@ describe Rack::Unreloader do
       update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require 'spec/dir'")
       update_app("App.call[:foo] = 1", 'spec/dir/subdir/a.rb')
       @ru.require('spec/app.rb')
-      ru.call({}).should == {:foo=>1}
+      ru.call({}).must_equal(:foo=>1)
       File.delete('spec/dir/subdir/a.rb')
       update_app("App.call[:foo] = 2", 'spec/dir/subdir/b.rb')
-      ru.call({}).should == {:foo=>2}
+      ru.call({}).must_equal(:foo=>2)
       log_match %r{\ALoading.*spec/app\.rb\z},
                 %r{\ALoading.*spec/dir/subdir/a\.rb\z},
                 %r{\ANew classes in .*spec/app\.rb: App\z},

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
-dependencies: []
+date: 2016-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.6.1
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Rack::Unreloader is a rack middleware that reloads application files when it
   detects changes, unloading constants defined in those files before reloading.
@@ -55,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Reload application when files change, unloading constants first