rack-unreloader 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 075553f6aa8699bd65671b7bcd249d59fa4e9bd3
-  data.tar.gz: c5a602b7b83f51f1cb1478a4b064297a5e7c44a6
+  metadata.gz: 1c8f1734dc2b5c882473017b36c57ebd8ec83ce9
+  data.tar.gz: 77139686abfd0970924657fd236717be42b70da5
 SHA512:
-  metadata.gz: 9cc298cb22d214f56ab5e2526df44a0504c52ecf13288ce6d472eb13fba07620ffdcfbcd1e7465cdc8034a0738d5d47a744319fa73a5983bfe66aa774796148c
-  data.tar.gz: 32239e90a7da77adcdfca3378e3e5c03091c58d1ad845871249f4dcc20791bc72dd9452b64a04373cf11a53f282d7c38edacde35ec708c8296273706d7db8640
+  metadata.gz: 15eb8fac861e37af6c853b115ab64c38d0ec270273fb13a09f0aa72fc94fe5007b884541f6c5732de1146564342a8b69d05435f22fd076c2fdd842564ebf22b7
+  data.tar.gz: b43aad4ee73d6218cad149d523aaa1e1f086bb7020719b78ec7b14e028e4f8530fb4c8e90429a3463344737f4dc4d6332431eecbd6e13d4cbec911f836a00c8c

data/CHANGELOG

@@ -1,3 +1,11 @@
+= 1.3.0 (2015-04-06)
+
+* Log when specified constant exists before loading file or does not exist after loading (jeremyevans)
+
+* Improve logging, making it explicit when files are unloaded and reloaded (jeremyevans)
+
+* Allow returning :ObjectSpace for require block to signal that ObjectSpace should be used to determine constants (jeremyevans)
+
 = 1.2.1 (2015-01-27)
 
 * Fix homepage in gemspec (jeremyevans)

data/README.rdoc

@@ -224,6 +224,11 @@ your models just use a capitalized version of the filename:
 
   Unreloader.require('models'){|f| File.basename(f).sub(/\.rb\z/, '').capitalize}
 
+In some cases, you may want to pass a block to require, but inside the block
+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.
+
 == Usage Outside Rack
 
 While <tt>Rack::Unreloader</tt> is usually in the development of rack applications,
@@ -234,10 +239,9 @@ reload the application.
 
 == 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.  It has additional features, improvements, and bug
-fixes.
+Rack::Unreloader was derived from Padrino's reloader.  The Padrino-specific parts
+were removed, and it now requires the user manually specify which files to monitor.
+It has additional features, improvements, and bug fixes.
 
 == Caveats
 
@@ -248,7 +252,8 @@ will not handle correctly.  If it isn't doing what you expect, add a logger:
 
 Unloading constants causes issues whenever references to the constant are
 cached anywhere instead of looking up the constant by name.  This is fairly
-common, and using this library can cause a memory leak in such a case.
+common, and using this library can cause a memory leak or unexpected
+behavior in such a case.
 
 Approaches that load a fresh environment for every request (or a fresh
 environment anytime there are any changes) are going to be more robust than

data/Rakefile

@@ -12,15 +12,16 @@ end
 
 begin
   begin
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-  rescue LoadError
+    raise LoadError if ENV['RSPEC1']
     # RSpec 2
     require "rspec/core/rake_task"
     spec_class = RSpec::Core::RakeTask
     spec_files_meth = :pattern=
+  rescue LoadError
+    # RSpec 1
+    require "spec/rake/spectask"
+    spec_class = Spec::Rake::SpecTask
+    spec_files_meth = :spec_files=
   end
 
   spec = lambda do |name, files, d|

data/lib/rack/unreloader/reloader.rb

@@ -15,7 +15,7 @@ module Rack
       # Rack::Unloader.new for details.
       def initialize(opts={})
         @logger = opts[:logger]
-        @classes = opts[:subclasses] ?  Array(opts[:subclasses]).map{|s| s.to_s} : %w'Object'
+        @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).
@@ -176,7 +176,7 @@ module Rack
         if m = VALID_CONSTANT_NAME_REGEXP.match(s)
           Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
         else
-          log("#{s.inspect} is not a valid constant name!")
+          log("Invalid constant name: #{s}")
         end
       end
 
@@ -229,8 +229,8 @@ module Rack
         return unless @monitor_files.has_key?(file)
         return unless options[:force] || file_changed?(file)
 
-        log "#{@monitor_files[file] ? 'Reloading' : 'Loading'} #{file}"
         prepare(file) # might call #safe_load recursively
+        log "Loading #{file}"
         begin
           require(file)
           commit(file)
@@ -257,8 +257,8 @@ module Rack
       # can be required again.
       def remove_feature(file)
         if @monitor_files.has_key?(file)
+          log "Unloading #{file}"
           $LOADED_FEATURES.delete(file)
-          log "Removed feature #{file}"
         end
       end
 
@@ -266,24 +266,24 @@ module Rack
       # by the file.
       def remove(name)
         file = @files[name] || return
-        remove_constants(name){file[:constants]}
+        remove_feature(name) if $LOADED_FEATURES.include?(name)
         file[:features].each{|feature| remove_feature(feature)}
+        remove_constants(name){file[:constants]}
         @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
+        yield.each{|constant| remove_constant(constant)}
+      end
 
-        if constants
-          constants.each{|constant| remove_constant(constant)}
-        end
+      # True if the constant is already defined, false if not
+      def constant_defined?(const)
+        constantize(const)
+        true
+      rescue
+        false
       end
 
       # Store the currently loaded classes and features, so in case of an error
@@ -291,33 +291,60 @@ module Rack
       def prepare(name)
         file = remove(name)
         @old_entries[name] = {:features => monitored_features}
+        if constants = constants_for(name)
+          defs = constants.select{|c| constant_defined?(c)}
+          unless defs.empty?
+            log "Constants already defined before loading #{name}: #{defs.join(" ")}"
+          end
+          @old_entries[name][:constants] = constants
+        else
+          @old_entries[name][:all_classes] = all_classes
+        end
+      end
 
-        unless @constants_defined[name]
-          @old_entries[name][:constants] = all_classes
+      # Returns nil if ObjectSpace should be used to load the constants.  Returns an array of
+      # constant name symbols loaded by the file if they have been manually specified.
+      def constants_for(name)
+        if (pr = @constants_defined[name]) && (constants = pr.call(name)) != :ObjectSpace
+          Array(constants)
+        end
+      end
+
+      # The constants that were loaded by the given file.  If ObjectSpace was used to check
+      # all classes loaded previously, then check for new classes loaded since.  If the constants 
+      # were explicitly specified, then use them directly
+      def constants_loaded_by(name)
+        if @old_entries[name][:all_classes]
+          new_classes(@old_entries[name][:all_classes])
+        else
+          @old_entries[name][:constants]
         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 = {:features  => monitored_features - @old_entries[name][:features] - [name]}
-        unless constants_defined = @constants_defined[name]
-          entry[:constants] = new_classes(@old_entries[name][:constants])
-        end
+        entry = {:features => monitored_features - @old_entries[name][:features] - [name], :constants=>constants_loaded_by(name)}
 
         @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?
+        defs, not_defs = entry[:constants].partition{|c| constant_defined?(c)}
+        unless not_defs.empty?
+          log "Constants not defined after loading #{name}: #{not_defs.join(' ')}"
+        end
+        unless defs.empty?
+          log("New classes in #{name}: #{defs.join(' ')}") 
+        end
+        unless entry[:features].empty?
+          log("New features in #{name}: #{entry[:features].to_a.join(' ')}") 
         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)
-        remove_constants(name){new_classes(@old_entries[name][:constants])}
+        remove_constants(name){constants_loaded_by(name)}
         @old_entries.delete(name)
       end
 
@@ -330,7 +357,7 @@ module Rack
       def all_classes
         rs = Set.new
 
-        ObjectSpace.each_object(Module).each do |mod|
+        ::ObjectSpace.each_object(Module).each do |mod|
           if !mod.name.to_s.empty? && monitored_module?(mod)
             rs << mod
           end

data/spec/unreloader_spec.rb

@@ -62,7 +62,7 @@ describe Rack::Unreloader do
   end
 
   def log_match(*logs)
-    logs.length.should == @logger.length
+    @logger.length.should == logs.length
     logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.should == l : log.should =~ l}
   end
 
@@ -102,9 +102,24 @@ describe Rack::Unreloader do
     ru.call({}).should == [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
+  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({}).should == [1]
+    update_app(code(2))
+    ru.call({}).should == [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
 
@@ -117,16 +132,16 @@ describe Rack::Unreloader do
     ru.call({}).should == [[2], [4]]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/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: (App App2|App2 App)\z},
               %r{\ANew features in .*spec/app\.rb: .*spec/app2\.rb\z},
-              %r{\AReloading.*spec/app2\.rb\z},
+              %r{\AUnloading.*spec/app2\.rb\z},
               "Removed constant App2",
-              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z},
               %r{\ANew classes in .*spec/app2\.rb: App2\z}
   end
 
@@ -139,23 +154,23 @@ describe Rack::Unreloader do
     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{\ARemoved feature .*/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{\AReloading.*spec/app2\.rb\z},
+              %r{\AUnloading.*spec/app2\.rb\z},
               "Removed constant App2",
-              %r{\ARemoved feature .*/spec/app2.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z},
               %r{\ANew classes in .*spec/app2\.rb: App2\z}
   end
 
   it "should log invalid constant names in :subclasses options" do
     ru(:subclasses=>%w'1 Object').call({}).should == [1]
     logger.uniq!
-    log_match %r{\ALoading.*spec/app\.rb\z},
-              '"1" is not a valid constant name!',
+    log_match 'Invalid constant name: 1',
+              %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
@@ -165,9 +180,9 @@ describe Rack::Unreloader do
     ru.call({}).should == [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
@@ -177,9 +192,9 @@ describe Rack::Unreloader do
     ru.call({}).should == [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
@@ -188,8 +203,8 @@ describe Rack::Unreloader do
     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},
-              %r{\ARemoved feature .*/spec/app.rb\z}
+              %r{\AUnloading.*spec/app\.rb\z},
+              %r{\ALoading.*spec/app\.rb\z}
   end
 
   it "should unload partially loaded modules if loading fails, and allow future loading" do
@@ -201,12 +216,12 @@ describe Rack::Unreloader do
     ru.call({}).should == [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ALoading.*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},
+              %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
@@ -216,9 +231,9 @@ describe Rack::Unreloader do
     ru.call({}).should == [2]
     log_match %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: Array::App\z},
-              %r{\AReloading.*spec/app\.rb\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant Array::App",
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %r{\ALoading.*spec/app\.rb\z},
               %r{\ANew classes in .*spec/app\.rb: Array::App\z}
   end
 
@@ -236,12 +251,12 @@ describe Rack::Unreloader do
               %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},
+              %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{\ARemoved feature .*/spec/app2.rb\z},
-              %r{\ARemoved feature .*/spec/app.rb\z},
+              %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}
@@ -255,9 +270,11 @@ describe Rack::Unreloader do
     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},
+              %r{\ANew classes in .*spec/app\.rb: App\z},
+              %r{\AUnloading.*spec/app\.rb\z},
               "Removed constant App",
-              %r{\ARemoved feature .*/spec/app.rb\z}
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App\z}
   end
 
   it "should handle anonymous classes" do
@@ -268,8 +285,8 @@ describe Rack::Unreloader do
     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}
+              %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
@@ -280,9 +297,22 @@ describe Rack::Unreloader do
     update_app(code(2))
     ru.call({}).should == [1, 2]
     log_match %r{\ALoading.*spec/app\.rb\z},
-              %r{\AReloading.*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{\ARemoved feature .*/spec/app.rb\z}
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\AConstants not defined after loading .*spec/app\.rb: Foo\z}
+  end
+
+  it "should log when specifying a constant that already exists" do
+    base_ru
+    update_app(code(1))
+    ::App2 = 1
+    @ru.require('spec/app.rb'){|f| 'App2'}
+    ru.call({}).should == [1]
+    log_match %r{\AConstants already defined before loading .*spec/app\.rb: App2\z},
+              %r{\ALoading.*spec/app\.rb\z},
+              %r{\ANew classes in .*spec/app\.rb: App2\z}
   end
 
   it "should handle recorded dependencies" do
@@ -404,8 +434,8 @@ describe Rack::Unreloader do
                 %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{\AReloading .*/spec/dir/a.rb\z},
-                %r{\ARemoved feature .*/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
@@ -420,8 +450,8 @@ describe Rack::Unreloader do
                 %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{\AReloading .*/spec/dir/subdir/a.rb\z},
-                %r{\ARemoved feature .*/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
@@ -461,7 +491,7 @@ describe Rack::Unreloader do
                 %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{\ARemoved feature .*/spec/dir/a.rb\z},
+                %r{\AUnloading .*/spec/dir/a.rb\z},
                 %r{\ALoading.*spec/dir/b\.rb\z}
     end
 
@@ -478,7 +508,7 @@ describe Rack::Unreloader do
                 %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{\ARemoved feature .*/spec/dir/subdir/a.rb\z},
+                %r{\AUnloading .*/spec/dir/subdir/a.rb\z},
                 %r{\ALoading.*spec/dir/subdir/b\.rb\z}
     end
   end

metadata

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