rack-unreloader 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 513c06d3763473095bfcfb9b22a55d5bff7e5ede857a957934923062dd72473f
-  data.tar.gz: 03bc800248c21507ac209104593019e3fc69a398f32a02b7e4e3371d4824d162
+  metadata.gz: f6fefe4d57aa2ea927929699e2a6aba2e8979cea284b0784fee379404b6f1726
+  data.tar.gz: 3aa21b88447194616e29d1ea2cf1181f102f5d58e6a29f4a11696a83d826a506
 SHA512:
-  metadata.gz: 83c6ad5ee6aa7650bf5de240949a20c54b4560c1ef943f3ebc8599a22788cd88c96214ee0f26d540f17eb16f26fe282357f52c1cd4b415980250bc18281675d7
-  data.tar.gz: 96a012e44fc868f4a3a2aa1395c5710156ef9302f36e23a3718af364e03e4f5bd411959c8fa2cf590eede2201208117ab4a47a36def1c6e95a5bb87c0c045978
+  metadata.gz: 6a5fbca1692b66ab4daf1f9b1677b15fb704d28bb972b26fdc15d78918fa37bed04657177438ff2351ba8c60a10105f7e138d869a4ab37fbd9e4143188c5685d
+  data.tar.gz: 12d9b2d24730e1f41da6089e5995c219af4b636755738405d1404e0be3f4044c8f935bd073ba53d92cada170761f79bfea82235c5b58d9ca6bc1dac1ee1b647f

data/CHANGELOG

@@ -1,3 +1,13 @@
+= 1.8.0 (2021-10-15)
+
+* Avoid warnings in verbose warning mode on Ruby 3+ (jeremyevans)
+
+* Check directory timestamps before looking for added or removed files (jeremyevans)
+
+* Add support for a :delete_hook option to Unreloader#require, called when a file is deleted (jeremyevans)
+
+* Handle cases where Module#name raises an exception (jeremyevans) (#9)
+
 = 1.7.0 (2019-03-18)
 
 * Add :handle_reload_errors option, for returning backtrace with error if there is an exception when reloading (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2015 Jeremy Evans
+Copyright (c) 2014-2021 Jeremy Evans
 Copyright (c) 2011 Padrino
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.rdoc

@@ -1,12 +1,13 @@
 = Rack::Unreloader
 
-Rack::Unreloader is a rack library that reloads application files when it
-detects changes, unloading constants defined in those files before reloading.
-Like other rack libraries for reloading, this can make application development
-much faster, as you don't need to restart the whole application when you change
-a single file.  Unlike most other rack libraries for reloading, this unloads
-constants before requiring files, avoiding issues when loading a file is not
-idempotent.
+Rack::Unreloader is a code reloader for {Rack}[https://github.com/rack/rack].
+It speeds up application development by automatically reloading stale code
+so that you don't have to restart your dev server every time you change a file.
+
+Unlike most other code loading libraries for Rack,
+this one ensures that reloads are clean and idempotent
+by _unloading_ relevant constants first, and it does so incrementally, only
+reloading the files that are modified.
 
 == Installation
 
@@ -18,54 +19,61 @@ Source code is available on GitHub at https://github.com/jeremyevans/rack-unrelo
 
 == Basic Usage
 
-Assuming a basic web application stored in +app.rb+:
+Before:
 
-  require 'roda'
+  # config.ru
 
-  class App < Roda
-    route do |r|
-      "Hello world!"
-    end
-  end
+  require './app'
 
-With a basic +config.ru+ like this:
-
-  require './app.rb'
   run App
 
-Change +config.ru+ to:
+After:
+
+  # config.ru
 
   require 'rack/unreloader'
   Unreloader = Rack::Unreloader.new{App}
-  require 'roda'
   Unreloader.require './app.rb'
+
   run Unreloader
 
-The block you pass to Rack::Unreloader.new should return the rack application
-to use.  If you make any changes to +app.rb+, <tt>Rack::Unreloader</tt> will remove any
-constants defined by requiring +app.rb+, and rerequire the file.
+Now, +app.rb+ will be monitored for changes on each incoming HTTP request.
 
-Note that this causes problems if +app.rb+ loads any new libraries that define
-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>.
+If changes are detected, +Rack::Unreloader+ will
+unload all constants defined inside it and then re-require it
+before proceeding with the request.
 
-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:
+== Handling Subclasses
 
-  require 'rack/unreloader'
-  Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda'){App}
-  Unreloader.require './app.rb'
-  run Unreloader
+By default, +Rack::Unreloader+ unloads *all* constants defined in +app.rb+.
+That includes third-party libraries, like +Roda+ or +JSON+ in the example below:
+
+  # app.rb
+
+  require 'roda'
+  require 'json'
+
+  class App < Roda
+    ...
+  end
 
-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>.
+Unloading these classes/modules isn't just unnecessary, it's dangerous.
+If your own code depends on them, your app will throw a +NameError+ after
+reloading when it tries to access them.
 
-When the +:handle_reload_errors+ option is given, most exceptions raised during
-reloading will cause the backtrace to be returned, instead of raising the error
-externally.  This can be useful if no middleware that wrap the Unreloader are
-rescuing exceptions.
+To reload only *subclasses* of +Roda+ (i.e. +App+), use the +:subclasses+
+option:
+
+  Rack::Unreloader.new(:subclasses=>%w'Roda'){App}
+
+== Handling Errors During Reloading
+
+By default, +Rack::Unreloader+ instances do not handle exceptions raised
+during reloading, so that it may be rescued elsewhere (e.g. manually or by middleware).
+You can use the +:handle_reload_errors+ option to send the backtrace directly to the
+client as the HTTP response:
+
+  Rack::Unreloader.new(handle_reload_errors: true){App}
 
 == Dependency Handling
 
@@ -88,7 +96,7 @@ to using:
 
   Unreloader.require './models.rb'
 
-The reason that the <tt>Rack::Unreloader</tt> instance is assigned to a constant in
+The reason that the +Rack::Unreloader+ instance is assigned to a constant in
 +config.ru+ is to make it easy to add reloadable dependencies in this way.
 
 It's even a better idea to require this dependency manually in +config.ru+,
@@ -212,9 +220,20 @@ The advantage for doing this is that new files added to the directory will be
 picked up automatically, and files deleted from the directory will be removed
 automatically. This applies to files in subdirectories of that directory as well.
 
+The +require+ method also supports a +:delete_hook+ option.  This option sets
+a hook that is called when the related file is deleted.  This is useful if adding
+a new file or reloading an existing file will handle things correctly, but
+removing the file will not.  One common case for this is when you have a shared data
+structure that is updated by the files, where adding or reloading the file will
+update the data structure, but deleting will not, and will leave stale entries in
+the data structure.  You can use the +:delete_hook+ option to remove the entries
+related to the file in the data structure:
+
+  Unreloader.require 'models', :delete_hook=>proc{|f| SHARED_HASH.delete(f)}
+
 == Speeding Things Up
 
-By default, <tt>Rack::Unreloader</tt> uses +ObjectSpace+ before and after requiring each
+By default, +Rack::Unreloader+ uses +ObjectSpace+ before and after requiring each
 file that it monitors, to see which classes and modules were defined by the
 require.  This is slow for large numbers of files.  In general use it isn't an
 issue as generally only a single file will be changed at a time, but it can
@@ -223,7 +242,7 @@ time.
 
 If you want to speed things up, you can provide a block to Rack::Unreloader#require,
 which will take the file name, and should return the name of the constants or array
-of constants to unload.  If you do this, <tt>Rack::Unreloader</tt> will no longer need
+of constants to unload.  If you do this, +Rack::Unreloader+ will no longer need
 to use +ObjectSpace+, which substantially speeds up startup.  For example, if all of
 your models just use a capitalized version of the filename:
 
@@ -236,7 +255,7 @@ block return the :ObjectSpace symbol.
 
 == chroot Support
 
-<tt>Rack::Unreloader#strip_path_prefix</tt> exists for supporting reloading in
++Rack::Unreloader#strip_path_prefix+ 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:
 
@@ -248,7 +267,7 @@ $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,
+While +Rack::Unreloader+ is usually in the development of rack applications,
 it doesn't depend on rack.  You can just instantiate an instance of Unreloader and
 use it to handle reloading in any ruby application, just by using the +require+ and
 +record_dependency+ to set up the metadata, and calling +reload!+ manually to

data/Rakefile

@@ -12,7 +12,7 @@ end
 
 desc "Run specs"
 task :spec do
-  sh "#{FileUtils::RUBY} spec/unreloader_spec.rb"
+  sh "#{FileUtils::RUBY} #{'-w ' if RUBY_VERSION >= '3'}spec/unreloader_spec.rb"
 end
 
 task :default => :spec

data/lib/rack/unreloader/reloader.rb

@@ -3,7 +3,7 @@ require 'set'
 module Rack
   class Unreloader
     class Reloader
-      F = ::File
+      File = ::File
 
       # Regexp for valid constant names, to prevent code execution.
       VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
@@ -18,13 +18,15 @@ module Rack
         @classes = opts[:subclasses] ?  Array(opts[:subclasses]).map(&:to_s) : %w'Object'
 
         # Hash of files being monitored for changes, keyed by absolute path of file name,
-        # with values being the last modified time (or nil if the file has not yet been loaded).
+        # with values being an array containing the last modified time (or nil if the file has
+        # not yet been loaded) and the delete hook.
         @monitor_files = {}
 
         # Hash of directories being monitored for changes, keyed by absolute path of directory name,
-        # with values being the an array with the last modified time (or nil if the directory has not
-        # yet been loaded), an array of files in the directory, and a block to pass to
-        # require_dependency for new files.
+        # with values being the an array with a hash of modified times for the directory and
+        # subdirectories (or nil if the directory has not yet been checked), an array of files in
+        # the directory, a block to pass to require_dependency for new files, and the delete_hook
+        # for the files in the directory.
         @monitor_dirs = {}
 
         # Hash of procs returning constants defined in files, keyed by absolute path
@@ -117,7 +119,7 @@ module Rack
         order.concat(files)
         order.uniq!
 
-        if F.directory?(path)
+        if File.directory?(path)
           (@monitor_files.keys & Unreloader.ruby_files(path)).each do |file|
             record_dependency(file, files)
           end
@@ -136,25 +138,28 @@ module Rack
         end
 
         removed_files = []
+        delete_hooks = []
 
-        @monitor_files.to_a.each do |file, time|
-          if F.file?(file)
+        @monitor_files.to_a.each do |file, (time, delete_hook)|
+          if File.file?(file)
             if file_changed?(file, time)
               changed_files << file
             end
           else
+            delete_hooks << [delete_hook, file] if delete_hook
             removed_files << file
           end
         end
 
         remove_files(removed_files)
+        delete_hooks.each{|hook, file| hook.call(file)}
 
         return if changed_files.empty?
 
         unless @dependencies.empty?
           changed_files = reload_files(changed_files)
           changed_files.flatten!
-          changed_files.map!{|f| F.directory?(f) ? Unreloader.ruby_files(f) : f}
+          changed_files.map!{|f| File.directory?(f) ? Unreloader.ruby_files(f) : f}
           changed_files.flatten!
           changed_files.uniq!
           
@@ -164,7 +169,7 @@ module Rack
         end
 
         unless @skip_reload.empty?
-          skip_reload = @skip_reload.map{|f| F.directory?(f) ? Unreloader.ruby_files(f) : f}
+          skip_reload = @skip_reload.map{|f| File.directory?(f) ? Unreloader.ruby_files(f) : f}
           skip_reload.flatten!
           skip_reload.uniq!
           changed_files -= skip_reload
@@ -177,18 +182,19 @@ module Rack
 
       # Require the given dependencies, monitoring them for changes.
       # Paths should be a file glob or an array of file globs.
-      def require_dependencies(paths, &block)
+      def require_dependencies(paths, opts={}, &block)
         options = {:cyclic => true}
+        delete_hook = opts[:delete_hook]
         error = nil 
 
         Unreloader.expand_paths(paths).each do |file|
-          if F.directory?(file)
-            @monitor_dirs[file] = [nil, [], block]
+          if File.directory?(file)
+            @monitor_dirs[file] = [nil, [], block, delete_hook]
             check_monitor_dir(file)
             next
           else
             @constants_defined[file] = block
-            @monitor_files[file] = nil
+            @monitor_files[file] = [nil, delete_hook]
           end
 
           begin
@@ -234,10 +240,21 @@ module Rack
         @logger.info(s) if @logger
       end
 
+      # A hash of modify times for all subdirectories of the given directory.
+      def subdir_times(dir)
+        h = {}
+        Find.find(dir) do |f|
+          h[f] = modified_at(f) if File.directory?(f)
+        end
+        h
+      end
+
       # Check a monitored directory for changes, adding new files and removing
       # deleted files.
       def check_monitor_dir(dir, changed_files=nil)
-        time, files, block = @monitor_dirs[dir]
+        subdir_times, files, block, delete_hook = md = @monitor_dirs[dir]
+        return if subdir_times && subdir_times.all?{|subdir, time| File.directory?(subdir) && modified_at(subdir) == time}
+        md[0] = subdir_times(dir)
 
         cur_files = Unreloader.ruby_files(dir)
         return if files == cur_files
@@ -250,8 +267,11 @@ module Rack
         end
 
         remove_files(removed_files)
+        if delete_hook
+          removed_files.each{|f| delete_hook.call(f)}
+        end
 
-        require_dependencies(new_files, &block)
+        require_dependencies(new_files, :delete_hook=>delete_hook, &block)
 
         new_files.each do |file|
           if deps = @dependencies[dir]
@@ -344,7 +364,7 @@ module Rack
       # Store the currently loaded classes and features, so in case of an error
       # this state can be rolled back to.
       def prepare(name)
-        file = remove(name)
+        remove(name)
         @old_entries[name] = {:features => monitored_features}
         if constants = constants_for(name)
           defs = constants.select{|c| constant_defined?(c)}
@@ -383,7 +403,7 @@ module Rack
 
         @files[name] = entry
         @old_entries.delete(name)
-        @monitor_files[name] = modified_at(name)
+        @monitor_files[name][0] = modified_at(name)
 
         defs, not_defs = entry[:constants].partition{|c| constant_defined?(c)}
         unless not_defs.empty?
@@ -413,7 +433,7 @@ module Rack
         rs = Set.new
 
         ::ObjectSpace.each_object(Module).each do |mod|
-          if !mod.name.to_s.empty? && monitored_module?(mod)
+          if !(mod.name rescue next).to_s.empty? && monitored_module?(mod)
             rs << mod
           end
         end
@@ -466,7 +486,7 @@ module Rack
       end
 
       # Returns true if the file is new or it's modification time changed.
-      def file_changed?(file, time = @monitor_files[file])
+      def file_changed?(file, time = @monitor_files[file][0])
         !time || modified_at(file) > time
       end
 
@@ -474,7 +494,7 @@ module Rack
       # to base the reloading on something other than the file's modification
       # time.
       def modified_at(file)
-        F.mtime(file)
+        File.mtime(file)
       end
     end
   end

data/lib/rack/unreloader.rb

@@ -9,14 +9,14 @@ module Rack
     MUTEX = Monitor.new
 
     # Reference to ::File as File would return Rack::File by default.
-    F = ::File
+    File = ::File
 
     # Given the list of paths, find all matching files, or matching ruby files
     # in subdirecories if given a directory, and return an array of expanded
     # paths.
     def self.expand_directory_paths(paths)
       expand_paths(paths).
-        map{|f| F.directory?(f) ? ruby_files(f) : f}.
+        map{|f| File.directory?(f) ? ruby_files(f) : f}.
         flatten
     end
 
@@ -27,7 +27,7 @@ module Rack
         flatten.
         map{|path| Dir.glob(path).sort_by{|filename| filename.count('/')}}.
         flatten.
-        map{|path| F.expand_path(path)}.
+        map{|path| File.expand_path(path)}.
         uniq
     end
 
@@ -47,6 +47,8 @@ module Rack
     # 
     # :cooldown :: The number of seconds to wait between checks for changed files.
     #              Defaults to 1.  Set to nil/false to not check for changed files.
+    # :handle_reload_errors :: Whether reload to handle reload errors by returning
+    #                          a 500 plain text response with the backtrace.
     # :reload :: Set to false to not setup a reloader, and just have require work
     #            directly.  Should be set to false in production mode.
     # :logger :: A Logger instance which will log information related to reloading.
@@ -85,9 +87,12 @@ module Rack
     end
 
     # Add a file glob or array of file globs to monitor for changes.
-    def require(paths, &block)
+    # Options:
+    # :delete_hook :: When a file being monitored is deleted, call
+    #                 this hook with the path of the deleted file.
+    def require(paths, opts={}, &block)
       if @reloader
-        @reloader.require_dependencies(paths, &block)
+        @reloader.require_dependencies(paths, opts, &block)
       else
         Unreloader.expand_directory_paths(paths).each{|f| super(f)}
       end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ require 'rubygems'
 $: << 'lib'
 ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 require 'minitest/hooks'
 
 module ModifiedAt
@@ -25,14 +25,24 @@ end
 
 class Minitest::Spec
   def code(i)
-    "class App; def self.call(env) @a end; @a ||= []; @a << #{i}; end"
+    "class App; class << self; def call(env) @a end; alias call call; end; @a ||= []; @a << #{i}; end"
   end
 
   def update_app(code, file=@filename)
-    ru.reloader.set_modified_time(file, @i += 1) if ru.reloader
+    if ru.reloader
+      ru.reloader.set_modified_time(File.dirname(file), @i += 1) unless File.file?(file)
+      ru.reloader.set_modified_time(file, @i += 1)
+    end
     File.open(file, 'wb'){|f| f.write(code)}
   end
 
+  def file_delete(file)
+    if ru.reloader
+      ru.reloader.set_modified_time(File.dirname(file), @i += 1)
+    end
+    File.delete(file)
+  end
+
   def logger
     return @logger if @logger
     @logger = []

data/spec/unreloader_spec.rb

@@ -32,7 +32,7 @@ describe Rack::Unreloader do
 
   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]
-    File.delete('spec/app.rb')
+    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},
@@ -131,7 +131,7 @@ 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({}).must_equal [1]
+    ru(:subclasses=>'Foo', :code=>"module App; def self.call(env) @a end; class << self; alias call call; 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({}).must_equal [1, 2]
     log_match %r{\ALoading.*spec/app\.rb\z},
@@ -218,7 +218,7 @@ describe Rack::Unreloader do
 
   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")
+    update_app("class App; def self.call(env) [@a, App2.a] end; class << self; alias call call; end; @a ||= []; @a << 1; end; class App2; def self.a; @a end; class << self; alias 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]]
     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")
@@ -288,6 +288,20 @@ describe Rack::Unreloader do
     ru.call({}).must_equal 4
   end
 
+  it "should handle modules where name raises an exception" do
+    m = Module.new{def self.name; raise end}
+    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({}).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}
+    m
+  end
+
   describe "with a directory" do
     include Minitest::Hooks
 
@@ -298,7 +312,7 @@ describe Rack::Unreloader do
     end
 
     after do
-      Dir['spec/dir/**/*.rb'].each{|f| File.delete(f)}
+      Dir['spec/dir/**/*.rb'].each{|f| file_delete(f)}
     end
 
     after(:all) do
@@ -353,7 +367,7 @@ describe Rack::Unreloader do
       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'
+      file_delete 'spec/dir/subdir/app_mod.rb'
       ru.call({}).must_equal 0
     end
 
@@ -374,7 +388,7 @@ describe Rack::Unreloader do
       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'
+      file_delete 'spec/dir/appb.rb'
       ru.call({}).must_equal 1
     end
 
@@ -440,7 +454,7 @@ describe Rack::Unreloader do
       update_app("App.call[:foo] = 1", 'spec/dir/a.rb')
       @ru.require('spec/app.rb')
       ru.call({}).must_equal(:foo=>1)
-      File.delete('spec/dir/a.rb')
+      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},
@@ -457,7 +471,7 @@ describe Rack::Unreloader do
       update_app("App.call[:foo] = 1", 'spec/dir/subdir/a.rb')
       @ru.require('spec/app.rb')
       ru.call({}).must_equal(:foo=>1)
-      File.delete('spec/dir/subdir/a.rb')
+      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},
@@ -467,5 +481,35 @@ describe Rack::Unreloader do
                 %r{\AUnloading .*/spec/dir/subdir/a.rb\z},
                 %r{\ALoading.*spec/dir/subdir/b\.rb\z}
     end
+
+    it "should call hook when dropping files deleted from the directory" do
+      base_ru
+      deletes = []
+      Object.const_set(:Deletes, deletes)
+      update_app("class App; @a = {}; def self.call(env=nil) @a end; end; RU.require('spec/dir', :delete_hook=>proc{|f| Deletes << f})")
+      update_app("App.call[:foo] = 1", 'spec/dir/a.rb')
+      @ru.require('spec/app.rb', :delete_hook=>proc{|f| deletes << f})
+      ru.call({}).must_equal(:foo=>1)
+      file_delete('spec/dir/a.rb')
+      update_app("App.call[:foo] = 2", 'spec/dir/b.rb')
+      ru.call({}).must_equal(:foo=>2)
+      deletes.must_equal [File.expand_path('spec/dir/a.rb')]
+      file_delete('spec/dir/b.rb')
+      ru.call({}).must_equal(:foo=>2)
+      deletes.must_equal [File.expand_path('spec/dir/a.rb'), File.expand_path('spec/dir/b.rb')]
+      file_delete('spec/app.rb')
+      proc{ru.call({})}.must_raise NameError
+      deletes.must_equal [File.expand_path('spec/dir/a.rb'), File.expand_path('spec/dir/b.rb'), File.expand_path('spec/app.rb')]
+      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},
+                %r{\AUnloading .*/spec/dir/b.rb\z},
+                %r{\AUnloading .*/spec/app.rb\z},
+                %r{\ARemoved constant App\z}
+      Object.send(:remove_const, :Deletes)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-18 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  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.
@@ -61,7 +75,11 @@ files:
 homepage: http://github.com/jeremyevans/rack-unreloader
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/rack-unreloader/issues
+  changelog_uri: https://github.com/jeremyevans/rack-unreloader/blob/master/CHANGELOG
+  mailing_list_uri: https://github.com/jeremyevans/rack-unreloader/discussions
+  source_code_uri: https://github.com/jeremyevans/rack-unreloader
 post_install_message: 
 rdoc_options:
 - "--quiet"
@@ -77,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Reload application when files change, unloading constants first