rack-unreloader 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d64b1a401d4679d7a1811a008c2cc5bb951b8722
-  data.tar.gz: ef510ae0a796be3d5f11e9d80ba842c9f351e764
+  metadata.gz: 63e0754f2064aacba7745d52c60d136019dd5fdf
+  data.tar.gz: 31d3d8223106f59d5fa739b429cbf08d6d47db31
 SHA512:
-  metadata.gz: 9791a0b04d89506251c8fbe9e16cc873f33b581b6927b029b08574170e1dd850048043b97f0e6e15760b5e3961d149132c7b9f7bb4f0ca082bc2be64635b464f
-  data.tar.gz: a6eefba4399f58d591bb474c027eefec4bacf633641736806d9f3f13127239107ea29bc5c25e9adad173e5c80f5e2827663b669ce530e6b8a496d71230bca405
+  metadata.gz: 6645aa444fd1c88c52c09f0de56894f640cf9404624f0e25197071b1498d1aa7745a1bb9a8e9416f3cc7d8aeacf4f993e552adaa06f4b1386be95db43aef4272
+  data.tar.gz: 26811ff5218e1fe20e15f0619dcfb4d4dbabcba2819c82e8c46f428fdfb1714a3348a12a931ba8065d5f6cb182336e989e6d98d93e7a2ac633f4c6c7d783fc43

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 1.6.0 (2017-02-24)
+
+* Add Unreloader#strip_path_prefix, designed to support chrooting (jeremyevans)
+
 = 1.5.0 (2016-03-10)
 
 * Handle deletions of monitored files (jeremyevans)

data/README.rdoc

@@ -106,7 +106,7 @@ to false if not in development:
 
   dev = ENV['RACK_ENV'] == 'development'
   require 'rack/unreloader'
-  Unreloader = Rack::Unreloader.new(:reload=>dev){App}
+  Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda Sequel::Model', :reload=>dev){App}
   Unreloader.require './models.rb'
   Unreloader.require './app.rb'
   run(dev ? Unreloader : App)
@@ -229,6 +229,18 @@ decide that instead of specifying the constants, ObjectSpace should be used to
 automatically determine the constants loaded. You can specify this by having the
 block return the :ObjectSpace symbol.
 
+== chroot Support
+
+<tt>Rack::Unreloader#strip_path_prefix</tt> exists for supporting reloading in
+chroot environments, where you chroot an application after it has been fully
+loaded, but still want to pick up changes to files inside the chroot. Example:
+
+  Unreloader.strip_path_prefix(Dir.pwd)
+  Dir.chroot(Dir.pwd)
+
+Note that Unreloader.strip_path_prefix also strips the path prefix from
+$LOADED_FEATURES, as that is necessary for correct operation.
+
 == Usage Outside Rack
 
 While <tt>Rack::Unreloader</tt> is usually in the development of rack applications,
@@ -262,8 +274,9 @@ for speed when using this library.
 
 == Implementation Support
 
-Rack::Unreloader works correctly on Ruby 1.8.7+ and Rubinius.  It only works on
-JRuby if you use a proc to specify the constants to unload.
+Rack::Unreloader works correctly on Ruby 1.8.7+, JRuby 9.1+, and Rubinius.  It
+also works on older versions of JRuby if you use a proc to specify the constants
+to unload.
 
 == License
 

data/Rakefile

@@ -12,7 +12,7 @@ end
 
 desc "Run specs"
 task :spec do
-  sh "#{FileUtils::RUBY} -rubygems -I lib spec/unreloader_spec.rb"
+  sh "#{FileUtils::RUBY} spec/unreloader_spec.rb"
 end
 
 task :default => :spec

data/lib/rack/unreloader.rb

@@ -116,5 +116,17 @@ module Rack
     def reload!
       @reloader.reload! if @reloader
     end
+
+    # Strip the given path prefix from all absolute paths used by the
+    # reloader.  This is designed when chrooting an application.
+    #
+    # Options:
+    # :strip_core :: Also strips the path prefix from $LOADED_FEATURES and
+    #              $LOAD_PATH.
+    def strip_path_prefix(path_prefix, opts={})
+      if @reloader
+        @reloader.strip_path_prefix(path_prefix)
+      end
+    end
   end
 end

data/lib/rack/unreloader/reloader.rb

@@ -53,6 +53,47 @@ module Rack
         @skip_reload = []
       end
 
+      # Strip the given path prefix from the internal data structures.
+      def strip_path_prefix(path_prefix)
+        empty = ''.freeze
+
+        # Strip the path prefix from $LOADED_FEATURES, otherwise the reloading won't work.
+        # Hopefully a future version of ruby will do this automatically when chrooting.
+        $LOADED_FEATURES.map!{|s| s.sub(path_prefix, empty)}
+
+        fix_path = lambda do |s|
+          s.sub(path_prefix, empty)
+        end
+
+        [@dependency_order, @skip_reload].each do |a|
+          a.map!(&fix_path)
+        end
+
+        [@files, @old_entries].each do |hash|
+          hash.each do |k,h|
+            h[:features].map!(&fix_path)
+          end
+        end
+        
+        @monitor_dirs.each_value do |a|
+          a[1].map!(&fix_path)
+        end
+
+        @dependencies.each_value do |a|
+          a.map!(&fix_path)
+        end
+
+        [@files, @old_entries, @monitor_files, @monitor_dirs, @constants_defined, @dependencies].each do |hash|
+          hash.keys.each do |k|
+            if k.start_with?(path_prefix)
+              hash[fix_path.call(k)] = hash.delete(k)
+            end
+          end
+        end
+
+        nil
+      end
+
       # Unload all reloadable constants and features, and clear the list
       # of files to monitor.
       def clear!

data/spec/spec_helper.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/rack/unreloader')
+require 'rubygems'
+$: << 'lib'
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/hooks'
+
+module ModifiedAt
+  def set_modified_time(file, time)
+    time = Time.now + time if time.is_a?(Integer)
+    modified_times[File.expand_path(file)] = time
+  end
+
+  def modified_times
+    @modified_times ||= {}
+  end
+
+  private
+
+  def modified_at(file)
+    modified_times[file] || super
+  end
+end
+
+class Minitest::Spec
+  def code(i)
+    "class App; def self.call(env) @a end; @a ||= []; @a << #{i}; end"
+  end
+
+  def update_app(code, file=@filename)
+    ru.reloader.set_modified_time(file, @i += 1) if ru.reloader
+    File.open(file, 'wb'){|f| f.write(code)}
+  end
+
+  def logger
+    return @logger if @logger
+    @logger = []
+    def @logger.method_missing(meth, log)
+      self << log
+    end
+    @logger
+  end
+
+  def base_ru(opts={})
+    block = opts[:block] || proc{App}
+    @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
+    @ru.reloader.extend ModifiedAt if @ru.reloader
+    Object.const_set(:RU, @ru)
+  end
+
+  def ru(opts={})
+    return @ru if @ru
+    base_ru(opts)
+    update_app(opts[:code]||code(1))
+    @ru.require @filename
+    @ru
+  end
+
+  def log_match(*logs)
+    @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
+    @i = 0
+    @filename = 'spec/app.rb'
+  end
+
+  after do
+    ru.reloader.clear! if ru.reloader
+    Object.send(:remove_const, :RU)
+    Object.send(:remove_const, :App) if defined?(::App)
+    Object.send(:remove_const, :App2) if defined?(::App2)
+    Dir['spec/app*.rb'].each{|f| File.delete(f)}
+  end
+end

data/spec/strip_paths_spec.rb

@@ -0,0 +1,858 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe Rack::Unreloader do
+  def self.it(*)
+    exit(1) unless Process.waitpid2(fork{super}).last.success?
+  end
+
+  def chroot
+    @ru.strip_path_prefix(Dir.pwd)
+    Dir.chroot(Dir.pwd)
+  end
+
+  it "should not reload files automatically if cooldown option is nil" do
+    ru(:cooldown => nil).call({}).must_equal [1]
+    chroot
+    update_app(code(2))
+    ru.call({}).must_equal [1]
+    @ru.reload!
+    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({}).must_equal [1]
+    file = 'spec/app_no_reload2.rb'
+    File.open(file, 'wb'){|f| f.write('ANR2 = 2')}
+    chroot
+    ru.require 'spec/app_no_*2.rb'
+    ANR2.must_equal 2
+  end
+
+  it "should unload constants contained in file and reload file if file changes" do
+    ru.call({}).must_equal [1]
+    chroot
+    update_app(code(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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  end
+
+  it "should stop monitoring file for changes if it is deleted constants contained in file and reload file if file changes" do
+    ru.call({}).must_equal [1]
+    chroot
+    File.delete('spec/app.rb')
+    proc{ru.call({})}.must_raise NameError
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AUnloading /spec/app\.rb\z},
+              "Removed constant App"
+  end
+
+  it "should check constants using ObjectSpace if require proc returns :ObjectSpace" do
+    base_ru
+    update_app(code(1))
+    @ru.require(@filename){|f| :ObjectSpace}
+    ru.call({}).must_equal [1]
+    chroot
+    update_app(code(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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  end
+
+  it "should pickup files added as dependencies when chrooting early" do
+    ru.call({}).must_equal [1]
+    chroot
+    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({}).must_equal [[2], [3]]
+    update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
+    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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z},
+              %r{\ANew classes in /spec/app\.rb: (App App2|App2 App)\z},
+              %r{\ANew features in /spec/app\.rb: /spec/app2\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z}
+  end
+
+  it "should pickup files added as dependencies when chrooting late" do
+    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({}).must_equal [[2], [3]]
+    chroot
+    update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
+    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},
+              "Removed constant App",
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z},
+              %r{\ANew classes in .*spec/app2\.rb: App2\z},
+              %r{\ANew classes in .*spec/app\.rb: (App App2|App2 App)\z},
+              %r{\ANew features in .*spec/app\.rb: .*spec/app2\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z}
+  end
+
+  it "should support :subclasses option and only unload subclasses of given class when chrooting early" do
+    ru(:subclasses=>'App').call({}).must_equal [1]
+    chroot
+    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({}).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({}).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},
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z},
+              %r{\ANew classes in /spec/app\.rb: App2\z},
+              %r{\ANew features in /spec/app\.rb: /spec/app2\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z}
+  end
+
+  it "should support :subclasses option and only unload subclasses of given class when chrooting late" do
+    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({}).must_equal [[1, 2], [3]]
+    chroot
+    update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
+    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},
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z},
+              %r{\ANew classes in .*spec/app2\.rb: App2\z},
+              %r{\ANew classes in .*spec/app\.rb: App2\z},
+              %r{\ANew features in .*spec/app\.rb: .*spec/app2\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app2\.rb: App2\z}
+  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({}).must_equal [1]
+    chroot
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  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({}).must_equal [1]
+    chroot
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  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({}).must_equal [1]
+    chroot
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    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 when chrooting early" do
+    ru.call({}).must_equal [1]
+    chroot
+    update_app("module App; def self.call(env) @a end; @a ||= []; raise 'foo'; end")
+    proc{ru.call({})}.must_raise RuntimeError
+    defined?(::App).must_be_nil
+    update_app(code(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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\AFailed to load /spec/app\.rb; removing partially defined constants\z},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  end
+
+  it "should unload partially loaded modules if loading fails, and allow future loading when chrooting late" do
+    ru.call({}).must_equal [1]
+    update_app("module App; def self.call(env) @a end; @a ||= []; raise 'foo'; end")
+    proc{ru.call({})}.must_raise RuntimeError
+    defined?(::App).must_be_nil
+    chroot
+    update_app(code(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},
+              "Removed constant App",
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\AFailed to load .*spec/app\.rb; removing partially defined constants\z},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  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({}).must_equal [1]
+    chroot
+    update_app("class Array::App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    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},
+              "Removed constant Array::App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: Array::App\z}
+  end
+
+  it "should not unload class defined in dependency if already defined in parent when chrooting early" do
+    base_ru
+    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({}).must_equal [2, 3]
+    chroot
+    update_app("class App; @a << 4 end", 'spec/app2.rb')
+    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({}).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},
+              %r{\ANew features in .*spec/app\.rb: .*spec/app2\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\AUnloading /spec/app\.rb\z},
+              %r{\AUnloading /spec/app2\.rb\z},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z},
+              %r{\ANew features in /spec/app\.rb: /spec/app2\.rb\z}
+  end
+
+  it "should not unload class defined in dependency if already defined in parent when chrooting late" do
+    base_ru
+    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({}).must_equal [2, 3]
+    update_app("class App; @a << 4 end", 'spec/app2.rb')
+    ru.call({}).must_equal [2, 3, 4]
+    chroot
+    update_app("class App; def self.call(env) @a end; @a ||= []; @a << 2; RU.require 'spec/app2.rb'; end")
+    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},
+              %r{\ANew features in .*spec/app\.rb: .*spec/app2\.rb\z},
+              %r{\AUnloading.*spec/app2\.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app2\.rb\z},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ALoading /spec/app2\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z},
+              %r{\ANew features in /spec/app\.rb: /spec/app2\.rb\z}
+  end
+
+  it "should allow specifying proc for which constants get removed" 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({}).must_equal [[1], [2]]
+    chroot
+    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({}).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},
+              "Removed constant App",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\ANew classes in /spec/app\.rb: App\z}
+  end
+
+  it "should handle anonymous classes" 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({}).must_equal [1]
+    chroot
+    update_app("$app = Class.new do def self.call(env) @a end; @a ||= []; @a << 2; end")
+    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}
+  end
+
+  it "should log when attempting to remove a class that doesn't exist" do
+    base_ru
+    update_app(code(1))
+    @ru.require('spec/app.rb'){|f| 'Foo'}
+    ru.call({}).must_equal [1]
+    chroot
+    update_app(code(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},
+              "Error removing constant: Foo",
+              %r{\ALoading /spec/app\.rb\z},
+              %r{\AConstants not defined after loading /spec/app\.rb: Foo\z}
+  end
+
+  it "should handle recorded dependencies when chrooting early" do
+    base_ru
+    update_app("module A; B = 1; end", 'spec/app_mod.rb')
+    update_app("class App; A = ::A; def self.call(env) A::B end; end")
+    ru.require 'spec/app_mod.rb'
+    ru.require 'spec/app.rb'
+    ru.record_dependency 'spec/app_mod.rb', 'spec/app.rb'
+    ru.call({}).must_equal 1
+    chroot
+    update_app("module A; B = 2; end", 'spec/app_mod.rb')
+    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({}).must_equal 3
+    update_app("module C; B = 4; end", 'spec/app_mod2.rb')
+    ru.call({}).must_equal 4
+  end
+
+  it "should handle recorded dependencies when chrooting middle" do
+    base_ru
+    update_app("module A; B = 1; end", 'spec/app_mod.rb')
+    update_app("class App; A = ::A; def self.call(env) A::B end; end")
+    ru.require 'spec/app_mod.rb'
+    ru.require 'spec/app.rb'
+    ru.record_dependency 'spec/app_mod.rb', 'spec/app.rb'
+    ru.call({}).must_equal 1
+    update_app("module A; B = 2; end", 'spec/app_mod.rb')
+    ru.call({}).must_equal 2
+    chroot
+    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({}).must_equal 3
+    update_app("module C; B = 4; end", 'spec/app_mod2.rb')
+    ru.call({}).must_equal 4
+  end
+
+  it "should handle recorded dependencies when chrooting late" do
+    base_ru
+    update_app("module A; B = 1; end", 'spec/app_mod.rb')
+    update_app("class App; A = ::A; def self.call(env) A::B end; end")
+    ru.require 'spec/app_mod.rb'
+    ru.require 'spec/app.rb'
+    ru.record_dependency 'spec/app_mod.rb', 'spec/app.rb'
+    ru.call({}).must_equal 1
+    update_app("module A; B = 2; end", 'spec/app_mod.rb')
+    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({}).must_equal 3
+    chroot
+    update_app("module C; B = 4; end", 'spec/app_mod2.rb')
+    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')
+      Dir.mkdir('spec/dir/subdir2')
+    end
+
+    after do
+      Dir['spec/dir/**/*.rb'].each{|f| File.delete(f)}
+    end
+
+    after(:all) do
+      Dir.rmdir('spec/dir/subdir')
+      Dir.rmdir('spec/dir/subdir2')
+      Dir.rmdir('spec/dir')
+    end
+
+    it "should handle recorded dependencies in directories when chrooting early" do
+      base_ru
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      update_app("class App; A = ::A; def self.call(env) A::B end; end")
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.call({}).must_equal 1
+      chroot
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      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({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+    end
+
+    it "should handle recorded dependencies in directories when chrooting middle" do
+      base_ru
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      update_app("class App; A = ::A; def self.call(env) A::B end; end")
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      chroot
+      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({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+    end
+
+    it "should handle recorded dependencies in directories when chrooting late" do
+      base_ru
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      update_app("class App; A = ::A; def self.call(env) A::B end; end")
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      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({}).must_equal 3
+      chroot
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 1" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      chroot
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 2" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      chroot
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 3" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      chroot
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 4" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      chroot
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 5" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      chroot
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later when chrooting 6" do
+      base_ru
+      update_app("class App; A = defined?(::A) ? ::A : Module.new{self::B = 0}; def self.call(env) A::B end; end")
+      ru.record_dependency 'spec/dir/subdir', 'spec/app.rb'
+      ru.record_dependency 'spec/dir/subdir2', 'spec/dir/subdir'
+      ru.require 'spec/app.rb'
+      ru.require 'spec/dir/subdir'
+      ru.require 'spec/dir/subdir2'
+      ru.call({}).must_equal 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).must_equal 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).must_equal 4
+      chroot
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).must_equal 0
+    end
+
+    it "should handle classes split into multiple files when chrooting 1" do
+      base_ru
+      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({}).must_equal 1
+      chroot
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      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({}).must_equal 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should handle classes split into multiple files when chrooting 2" do
+      base_ru
+      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({}).must_equal 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      chroot
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      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({}).must_equal 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should handle classes split into multiple files when chrooting 3" do
+      base_ru
+      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({}).must_equal 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      chroot
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      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({}).must_equal 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should handle classes split into multiple files when chrooting 4" do
+      base_ru
+      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({}).must_equal 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      ru.call({}).must_equal 341
+      chroot
+      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({}).must_equal 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should handle classes split into multiple files when chrooting 5" do
+      base_ru
+      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({}).must_equal 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      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({}).must_equal 561
+      chroot
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should handle classes split into multiple files when chrooting 6" do
+      base_ru
+      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({}).must_equal 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      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({}).must_equal 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).must_equal 61
+      chroot
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).must_equal 1
+    end
+
+    it "should pick up changes to files in that directory" do
+      base_ru
+      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({}).must_equal(:foo=>1)
+      chroot
+      update_app("App.call[:foo] = 2", 'spec/dir/a.rb')
+      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},
+                %r{\ANew features in .*spec/app\.rb: .*spec/dir/a\.rb\z},
+                %r{\AUnloading /spec/dir/a.rb\z},
+                %r{\ALoading /spec/dir/a.rb\z}
+    end
+
+    it "should pick up changes to files in subdirectories" do
+      base_ru
+      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({}).must_equal(:foo=>1)
+      chroot
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
+      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},
+                %r{\ANew features in .*spec/app\.rb: .*spec/dir/subdir/a\.rb\z},
+                %r{\AUnloading /spec/dir/subdir/a.rb\z},
+                %r{\ALoading /spec/dir/subdir/a.rb\z}
+    end
+
+    it "should pick up new files added to the directory" 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({}).must_equal({})
+      chroot
+      update_app("App.call[:foo] = 2", 'spec/dir/a.rb')
+      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}
+    end
+
+    it "should pick up new files added to subdirectories" 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({}).must_equal({})
+      chroot
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
+      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}
+    end
+
+    it "should drop files deleted from the directory" do
+      base_ru
+      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({}).must_equal(:foo=>1)
+      chroot
+      File.delete('spec/dir/a.rb')
+      update_app("App.call[:foo] = 2", 'spec/dir/b.rb')
+      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},
+                %r{\ANew features in .*spec/app\.rb: .*spec/dir/a\.rb\z},
+                %r{\AUnloading /spec/dir/a.rb\z},
+                %r{\ALoading /spec/dir/b\.rb\z}
+    end
+
+    it "should drop files deleted from subdirectories" do
+      base_ru
+      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({}).must_equal(:foo=>1)
+      chroot
+      File.delete('spec/dir/subdir/a.rb')
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/b.rb')
+      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},
+                %r{\ANew features in .*spec/app\.rb: .*spec/dir/subdir/a\.rb\z},
+                %r{\AUnloading /spec/dir/subdir/a.rb\z},
+                %r{\ALoading /spec/dir/subdir/b\.rb\z}
+    end
+  end
+end

data/spec/unreloader_spec.rb

@@ -1,76 +1,6 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/rack/unreloader')
-gem 'minitest'
-require 'minitest/autorun'
-require 'minitest/hooks'
-
-module ModifiedAt
-  def set_modified_time(file, time)
-    modified_times[File.expand_path(file)] = time
-  end
-
-  def modified_times
-    @modified_times ||= {}
-  end
-
-  private
-
-  def modified_at(file)
-    modified_times[file] || super
-  end
-end
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe Rack::Unreloader do
-  def code(i)
-    "class App; def self.call(env) @a end; @a ||= []; @a << #{i}; end"
-  end
-
-  def update_app(code, file=@filename)
-    ru.reloader.set_modified_time(file, @i += 1) if ru.reloader
-    File.open(file, 'wb'){|f| f.write(code)}
-  end
-
-  def logger
-    return @logger if @logger
-    @logger = []
-    def @logger.method_missing(meth, log)
-      self << log
-    end
-    @logger
-  end
-
-  def base_ru(opts={})
-    block = opts[:block] || proc{App}
-    @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
-    @ru.reloader.extend ModifiedAt if @ru.reloader
-    Object.const_set(:RU, @ru)
-  end
-
-  def ru(opts={})
-    return @ru if @ru
-    base_ru(opts)
-    update_app(opts[:code]||code(1))
-    @ru.require @filename
-    @ru
-  end
-
-  def log_match(*logs)
-    @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
-    @i = 0
-    @filename = 'spec/app.rb'
-  end
-
-  after do
-    ru.reloader.clear! if ru.reloader
-    Object.send(:remove_const, :RU)
-    Object.send(:remove_const, :App) if defined?(::App)
-    Object.send(:remove_const, :App2) if defined?(::App2)
-    Dir['spec/app*.rb'].each{|f| File.delete(f)}
-  end
-
   it "should not reload files automatically if cooldown option is nil" do
     ru(:cooldown => nil).call({}).must_equal [1]
     update_app(code(2))
@@ -213,7 +143,7 @@ describe Rack::Unreloader do
     ru.call({}).must_equal [1]
     update_app("module App; def self.call(env) @a end; @a ||= []; raise 'foo'; end")
     proc{ru.call({})}.must_raise RuntimeError
-    defined?(::App).must_equal nil
+    defined?(::App).must_be_nil
     update_app(code(2))
     ru.call({}).must_equal [2]
     log_match %r{\ALoading.*spec/app\.rb\z},

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-10 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -55,6 +55,8 @@ files:
 - Rakefile
 - lib/rack/unreloader.rb
 - lib/rack/unreloader/reloader.rb
+- spec/spec_helper.rb
+- spec/strip_paths_spec.rb
 - spec/unreloader_spec.rb
 homepage: http://github.com/jeremyevans/rack-unreloader
 licenses:
@@ -83,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Reload application when files change, unloading constants first