rack-unreloader 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7665e2203b2b2f7ac74d05e6c0b5b2c60d7d89d8
-  data.tar.gz: 19cd1b3fcf725bdaf58db40ba67426c38b3823d1
+  metadata.gz: 4e78994d15fb3130a66a1b0c4cddd957bbc7ed5a
+  data.tar.gz: 3151916048c0f97a461e6bd1a3e5d06cb5945943
 SHA512:
-  metadata.gz: 7810e9036260c1a517f544783e755997deeb759fcb56e05fdc2ee16109de4c74c907f94a019fe42c503610255797d4f04f76060ff8dde732037eb15df52b90a2
-  data.tar.gz: 17a0ea4463d61cfb959e72ce724c28fecba47dc7ac098ab0b01559c17f8e90026436b982da342335610d281f4fd652b3f13bfd5b1d1b10555d8ec590410036df
+  metadata.gz: 184ff5f426d8c587377e045954d2968b562dd8bd3e823c3968efda3556104a33b8df68fafb3aec4269770f7014973e46382302756fddeaf1c99191a39f80dbb9
+  data.tar.gz: 0877f19d6d65db719317c4d52a0cc1acb283f68b121af8a54b296c1e97cf7303d76bf59d33d293e9e3a06101d38add35a70fb4fe99d356877ead32d3bf3dd0b2

data/CHANGELOG

@@ -1,3 +1,13 @@
+= 1.0.0 (2014-08-12)
+
+* Ignore anonymous classes/modules (jeremyevans)
+
+* Log when attempting to remove a constant that doesn't exist (jeremyevans)
+
+* Allow specifying constants to remove via a block to require, instead of using ObjectSpace (jeremyevans)
+
+* Don't unload constants defined in parents when loading dependencies (jeremyevans)
+
 = 0.9.0 (2014-08-04)
 
 * Initial public release

data/README.rdoc

@@ -35,7 +35,7 @@ With a basic +config.ru+ like this:
 
 Change +config.ru+ to:
 
-  require 'rack-unreloader'
+  require 'rack/unreloader'
   Unreloader = Rack::Unreloader.new{App}
   require 'roda'
   Unreloader.require './app.rb'
@@ -53,7 +53,7 @@ code requires the +roda+ library normally before requiring +app.rb+ using
 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'
+  require 'rack/unreloader'
   Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda'){App}
   Unreloader.require './app.rb'
   run Unreloader
@@ -89,7 +89,7 @@ The reason that the <tt>Rack::Unreloader</tt> instance is assigned to a constant
 It's even a better idea to require this dependency manually in +config.ru+,
 before requiring +app.rb+:
 
-  require 'rack-unreloader'
+  require 'rack/unreloader'
   Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda Sequel::Model'){App}
   Unreloader.require './models.rb'
   Unreloader.require './app.rb'
@@ -104,7 +104,7 @@ Assuming you use +RACK_ENV+ to determine development mode, you can change
 +config.ru+ to:
 
   if ENV['RACK_ENV'] == 'development'
-    require 'rack-unreloader'
+    require 'rack/unreloader'
     Unreloader = Rack::Unreloader.new{App}
     Unreloader.require './models.rb'
     Unreloader.require './app.rb'
@@ -128,6 +128,10 @@ need to specify the module name if you want to reload it:
 
   Unreloader = Rack::Unreloader.new(:subclasses=>%w'MyModule'){App}
 
+Note that if the modules defined are included in any classes, this doesn't
+uninclude them (ruby doesn't support that), so there won't be a change to
+that class until that class is reloaded as well.
+
 == Requiring
 
 Rack::Unreloader#require is a little different than require in that it takes
@@ -146,11 +150,29 @@ You can use the usual file globbing:
 
   Unreloader.require 'models/*.rb'
 
+== Speeding Things Up
+
+By default, <tt>Rack::Unreloader</tt> 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 general only a single file will be changed at a time, but it can
+significantly slow down startup when all files are being loaded at the same
+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
+to use +ObjectSpace+, which substantially speeds up startup.  For example, if all of
+your models just use a capitalized version of the filename:
+
+  Unreloader.require('models/*.rb'){|f| File.basename(f).sub(/\.rb\z/, '').capitalize}
+
 == History
 
 Rack::Unreloader was derived from Padrino's reloader.  It is significantly smaller
 as it cuts out a lot of Padrino-specific code, and it forces the user to manually
-specify what files to monitor.
+specify what files to monitor.  It has additional features, improvements, and bug
+fixes.
 
 == Caveats
 
@@ -168,6 +190,11 @@ environment anytime there are any changes) are going to be more robust than
 this approach, but probably slower.  Be aware that you are trading robustness
 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.
+
 == License
 
 MIT

data/lib/rack/unreloader.rb

@@ -21,6 +21,11 @@ module Rack
         # with values being the last modified time (or nil if the file has not yet been loaded).
         @monitor_files = {}
 
+        # Hash of procs returning constants defined in files, keyed by absolute path
+        # of file name.  If there is no proc, must call ObjectSpace before and after
+        # loading files to detect changes, which is slower.
+        @constants_defined = {}
+
         # Hash keyed by absolute path of file name, storing constants and other
         # filenames that the key loads.  Values should be hashes with :constants
         # and :features keys, and arrays of values.
@@ -59,7 +64,7 @@ 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)
+      def require_dependencies(paths, &block)
         options = {:cyclic => true}
         error = nil 
 
@@ -71,6 +76,7 @@ module Rack
           uniq.
           each do |file|
 
+          @constants_defined[file] = block
           @monitor_files[file] = nil
           begin
             safe_load(file, options)
@@ -94,8 +100,8 @@ module Rack
         return unless @monitor_files.has_key?(file)
         return unless options[:force] || file_changed?(file)
 
-        prepare(file) # might call #safe_load recursively
         log "#{@monitor_files[file] ? 'Reloading' : 'Loading'} #{file}"
+        prepare(file) # might call #safe_load recursively
         begin
           require(file)
           commit(file)
@@ -115,12 +121,16 @@ module Rack
         base.send :remove_const, object
         log "Removed constant #{const}"
       rescue NameError
+        log "Error removing constant: #{const}"
       end
 
       # Remove a feature if it is being monitored for reloading, so it
       # can be required again.
       def remove_feature(file)
-        $LOADED_FEATURES.delete(file) if @monitor_files.has_key?(file)
+        if @monitor_files.has_key?(file)
+          $LOADED_FEATURES.delete(file)
+          log "Removed feature #{file}"
+        end
       end
 
       # Unload all reloadable constants and features, and clear the list
@@ -128,7 +138,6 @@ module Rack
       def clear!
         @files.keys.each do |file|
           remove(file)
-          remove_feature(file)
         end
         @monitor_files = {}
         @old_entries = {}
@@ -138,49 +147,75 @@ module Rack
       # by the file.
       def remove(name)
         file = @files[name] || return
-        file[:constants].each{|constant| remove_constant(constant)}
+        remove_constants(name){file[:constants]}
         file[:features].each{|feature| remove_feature(feature)}
         @files.delete(name)
+        remove_feature(name) if $LOADED_FEATURES.include?(name)
+      end
+
+      # Remove constants defined in file.  Uses the stored block if there is
+      # one for the file name, or the given block.
+      def remove_constants(name)
+        constants = if pr = @constants_defined[name] 
+          Array(pr.call(name))
+        else
+          yield
+        end
+
+        if constants
+          constants.each{|constant| remove_constant(constant)}
+        end
       end
 
       # 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)
-        old_features = Set.new($LOADED_FEATURES)
-        @old_entries[name] = {:constants => all_classes, :features => old_features}
-        features = file && file[:features] || []
-        features.each{|feature| safe_load(feature, :force => true)}
-        remove_feature(name) if old_features.include?(name)
+        @old_entries[name] = {:features => monitored_features}
+
+        unless @constants_defined[name]
+          @old_entries[name][:constants] = all_classes
+        end
       end
 
       # Commit the changed state after requiring the the file, recording the new
       # classes and features added by the file.
       def commit(name)
-        entry = {
-          :constants => new_classes(@old_entries[name][:constants]),
-          :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
-        }
+        entry = {:features  => monitored_features - @old_entries[name][:features] - [name]}
+        unless constants_defined = @constants_defined[name]
+          entry[:constants] = new_classes(@old_entries[name][:constants])
+        end
+
         @files[name] = entry
         @old_entries.delete(name)
         @monitor_files[name] = modified_at(name)
+
+        unless constants_defined
+          log("New classes in #{name}: #{entry[:constants].to_a.join(' ')}") unless entry[:constants].empty?
+        end
+        log("New features in #{name}: #{entry[:features].to_a.join(' ')}") unless entry[:features].empty?
       end
 
       # Rollback the changes made by requiring the file, restoring the previous state.
       def rollback(name)
-        new_classes(@old_entries[name][:constants]).each{|klass| remove_constant(klass)}
+        remove_constants(name){new_classes(@old_entries[name][:constants])}
         @old_entries.delete(name)
       end
 
       private
 
+      # The current loaded features that are being monitored
+      def monitored_features
+        Set.new($LOADED_FEATURES) & @monitor_files.keys
+      end
+
       # Return a set of all classes in the ObjectSpace.
       def all_classes
         rs = Set.new
 
-        ObjectSpace.each_object(Module).each do |klass|
-          if monitored_class?(klass)
-            rs << klass
+        ObjectSpace.each_object(Module).each do |mod|
+          if !mod.name.to_s.empty? && monitored_module?(mod)
+            rs << mod
           end
         end
 
@@ -189,20 +224,20 @@ module Rack
 
       # Return whether the given klass is a monitored class that could
       # be unloaded.
-      def monitored_class?(klass)
+      def monitored_module?(mod)
         @classes.any? do |c|
           c = constantize(c) rescue false
 
-          if klass.is_a?(Class)
+          if mod.is_a?(Class)
             # Reload the class if it is a subclass if the current class
-            (klass < c) rescue false
+            (mod < c) rescue false
           elsif c == Object
             # If reloading for all classes, reload for all modules as well
             true
           else
             # Otherwise, reload only if the module matches exactly, since
             # modules don't have superclasses.
-            klass == c
+            mod == c
           end
         end
       end
@@ -257,8 +292,8 @@ module Rack
     end
 
     # Add a file glob or array of file globs to monitor for changes.
-    def require(depends)
-      @reloader.require_dependencies(depends)
+    def require(depends, &block)
+      @reloader.require_dependencies(depends, &block)
     end
   end
 end

data/spec/unreloader_spec.rb

@@ -35,20 +35,23 @@ describe Rack::Unreloader do
     @logger
   end
 
-  def ru(opts={})
-    return @ru if @ru
+  def base_ru(opts={})
     block = opts[:block] || proc{App}
     @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
     @ru.reloader.extend ModifiedAt
     Object.const_set(:RU, @ru)
+  end
+
+  def ru(opts={})
+    return @ru if @ru
+    base_ru(opts)
     update_app(opts[:code]||code(1))
-    yield if block_given?
     @ru.require 'spec/app.rb'
     @ru
   end
 
   def log_match(*logs)
-    logs.length == @logger.length
+    logs.length.should == @logger.length
     logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.should == l : log.should =~ l}
   end
 
@@ -65,26 +68,41 @@ describe Rack::Unreloader do
     Dir['spec/app*.rb'].each{|f| File.delete(f)}
   end
 
-  it "it should unload constants contained in file and reload file if file changes" do
+  it "should unload constants contained in file and reload file if file changes" do
     ru.call({}).should == [1]
     update_app(code(2))
     ru.call({}).should == [2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
-  it "it should pickup files added as dependencies" do
+  it "should pickup files added as dependencies" do
     ru.call({}).should == [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]]
     update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
     ru.call({}).should == [[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}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z},
-              %r{\ALoading.*spec/app2\.rb\z}, "Removed constant App2", %r{\AReloading.*spec/app2\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/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{\AReloading.*spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\ANew classes in .*spec/app2\.rb: App2\z}
   end
 
-  it "it should support :subclasses option and only unload subclasses of given class" do
+  it "should support :subclasses option and only unload subclasses of given class" do
     ru(:subclasses=>'App').call({}).should == [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')
@@ -92,54 +110,150 @@ describe Rack::Unreloader do
     update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
     ru.call({}).should == [[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{\AReloading.*spec/app\.rb\z},
-              %r{\ALoading.*spec/app2\.rb\z}, "Removed constant App2", %r{\AReloading.*spec/app2\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              %r{\ARemoved feature .*/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{\AReloading.*spec/app2\.rb\z},
+              "Removed constant App2",
+              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\ANew classes in .*spec/app2\.rb: App2\z}
   end
 
-  it "it log invalid constant names in :subclasses options" do
+  it "should log invalid constant names in :subclasses options" do
     ru(:subclasses=>%w'1 Object').call({}).should == [1]
     logger.uniq!
-    log_match('"1" is not a valid constant name!', %r{\ALoading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              '"1" is not a valid constant name!',
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
-  it "it should unload modules before reloading similar to classes" do
+  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]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
     ru.call({}).should == [2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
-  it "it should unload specific modules by name via :subclasses option" do
+  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]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
     ru.call({}).should == [2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
-  it "it should not unload modules by name if :subclasses option used and module not present" do
+  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]
     update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
     ru.call({}).should == [1, 2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, %r{\AReloading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              %r{\ARemoved feature .*/spec/app.rb\z}
   end
 
-  it "it unload partially loaded modules if loading fails, and allow future loading" do
+  it "should unload partially loaded modules if loading fails, and allow future loading" do
     ru.call({}).should == [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
     update_app(code(2))
     ru.call({}).should == [2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z},
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app.rb\z},
               %r{\AFailed to load .*spec/app\.rb; removing partially defined constants\z},
-             "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+              "Removed constant App",
+              %r{\AReloading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
-  it "it should unload classes in namespaces" do
+  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]
     update_app("class Array::App; def self.call(env) @a end; @a ||= []; @a << 2; end")
     ru.call({}).should == [2]
-    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant Array::App", %r{\AReloading.*spec/app\.rb\z})
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: Array::App\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant Array::App",
+              %r{\ARemoved feature .*/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" 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({}).should == [2, 3]
+    update_app("class App; @a << 4 end", 'spec/app2.rb')
+    ru.call({}).should == [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]
+    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{\AReloading.*spec/app2\.rb\z},
+              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\ARemoved feature .*/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({}).should == [[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]]
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Removed constant App",
+              %r{\ARemoved feature .*/spec/app.rb\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({}).should == [1]
+    update_app("$app = Class.new do def self.call(env) @a end; @a ||= []; @a << 2; end")
+    ru.call({}).should == [2]
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              %r{\ARemoved feature .*/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({}).should == [1]
+    update_app(code(2))
+    ru.call({}).should == [1, 2]
+    log_match %r{\ALoading.*spec/app\.rb\z},
+              %r{\AReloading.*spec/app\.rb\z},
+              "Error removing constant: Foo",
+              %r{\ARemoved feature .*/spec/app.rb\z}
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-04 00:00:00.000000000 Z
+date: 2014-08-12 00:00:00.000000000 Z
 dependencies: []
 description: |
   Rack::Unreloader is a rack middleware that reloads application files when it