rack-unreloader 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8eacfdd6cd0d57685d8835bcfbc35bb716cc0241
-  data.tar.gz: eed0b264873367b89e234d9b74f1b47805ce48f3
+  metadata.gz: 37c98d1ba331382609dbc5b74058d02f6f194bc2
+  data.tar.gz: 77ae22b4fd6bd6a55f3ceb44d21e632d1fc87a77
 SHA512:
-  metadata.gz: 61c47de205a000b7048f516d3c841cc4dc20c88b565be214330e868a3c47a7e2561f90d4bcb7a9ed23eb10d62133639ae0e437e23b528a2f4ff362c8fb179def
-  data.tar.gz: 0eb1923fb9131e0a84b4ad020b54538bbd69ae7665bcf6f3bd5dc328685491a67aaec2c522baa01a00e1a4669bbebe0f803d65bc00f8f9eea31b1cd38e40fa40
+  metadata.gz: 41a3897cfab23c354c236f64c6ad9e6134c3170d2a6b4237a645a9ddc2ca8171bb99208dd11264402117b22f47682b3500590e709577a5fe747eab1536053120
+  data.tar.gz: f87b6f3e092f3341bb7bb82b20e2ace71ad3e424b4b676d5a481ad9dc724994fefea012967b202c4cf4a24fb083e50856c3209d15973b2e16961757bcb4d585d

data/CHANGELOG

@@ -1,3 +1,21 @@
+= 1.2.0 (2015-01-24)
+
+* Add Unreloader#record_split_class, for handling classes split into multiple files (jeremyevans)
+
+* Add Unreloader#reload!, for manually checking for changed files, useful for non-rack applications (jeremyevans)
+
+* Make most methods in the Reloader private (jeremyevans)
+
+* Separate reloading logic into separate file, so using unreloader in production takes less memory (jeremyevans)
+
+* Add the ability to record dependencies, making it possible to correctly support modules and superclasses (jeremyevans)
+
+* Add :reload option, set to false to not support reloading, useful in production mode (jeremyevans)
+
+* Document that setting the :cooldown option to nil makes the Unreloader not reload (celsworth, jeremyevans) (#3)
+
+* Handle files in subdirectories when monitoring directories (celsworth) (#2)
+
 = 1.1.0 (2014-09-25)
 
 * Allow monitoring of directories, so that new files can be picked up, and deleted files removed (jeremyevans)

data/MIT-LICENSE

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

data/README.rdoc

@@ -97,28 +97,24 @@ before requiring +app.rb+:
 
 This way, changing your +app.rb+ file will not reload your +models.rb+ file.
 
-== Only in Development Mode
-
-In general, you are only going to want to run this in development mode.
-Assuming you use +RACK_ENV+ to determine development mode, you can change
-+config.ru+ to:
-
-  if ENV['RACK_ENV'] == 'development'
-    require 'rack/unreloader'
-    Unreloader = Rack::Unreloader.new{App}
-    Unreloader.require './models.rb'
-    Unreloader.require './app.rb'
-    run Unreloader
-  else
-    require './app.rb'
-    run App
-  end
+== Only Reload in Development Mode
+
+In general, you are only going to want to reload code in development mode.
+To simplify things, you can use rack-unreloader both in development and
+production, and just not have it reload in production by setting +:reload+
+to false if not in development:
 
-If there are dependencies that you don't want to require directly in your
-+config.ru+, but you do want to use <tt>Rack::Unreloader</tt> for them in
-development, you can do:
+  dev = ENV['RACK_ENV'] == 'development'
+  require 'rack/unreloader'
+  Unreloader = Rack::Unreloader.new(:reload=>dev){App}
+  Unreloader.require './models.rb'
+  Unreloader.require './app.rb'
+  run(dev ? Unreloader : App)
 
-  (defined?(Unreloader) ? Unreloader : Kernel).require './models.rb'
+By running the App instead of Unreloader in production mode, there is no
+performance penalty.  The advantage of this approach is you can use
+Unreloader.require to require files regardless of whether you are using
+development or production mode.
 
 == Modules
 
@@ -128,9 +124,61 @@ 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.
+== Dependencies
+
+To correctly handle modules and superclasses, if a change is made to a module
+or superclass, you generally want to reload all classes that include the
+module or subclass the superclass, so they they pick up the change to the
+module or superclass.
+
+You can specify the file dependencies when using rack-unreloader:
+
+  Unreload.record_dependency('lib/module_file.rb', %w'models/mod1.rb models/mod2.rb')
+
+If lib/module_file.rb is changed, rack-unreloader will reload models/mod1.rb
+and models/mod2.rb after reloading lib/module_file.rb.
+
+You can provide directories when requiring dependencies.  For example:
+
+  Unreload.record_dependency('helpers', %w'app.rb')
+
+will make it so the addition of any ruby files to the helpers directory
+will trigger a reload of +app.rb+, and future changes to any of those files
+will also trigger of reload of +app.rb+.  Additionally, deleting any ruby files
+in the helpers directory will also trigger a reload of +app.rb+.
+
+You can also use a directory as the second argument:
+
+  Unreload.record_dependency('mod.rb', 'models')
+
+With this, any change to +mod.rb+ will trigger a reload of all ruby files in
+the models directory, even if such files are added later.
+
+When using +record_dependencies+ with a directory, you should also call
++require+ with that directory, as opposed to specifically requiring
+individual files inside the directory.
+
+== Classes Split Into Multiple Files
+
+Rack::Unreloader handles classes split into multiple files, where there is
+a main file for the class that requires the other files that define the
+class.  Assuming the main class file is +app.rb+, and other files that
+make up the class are in +helpers+:
+
+  # inside config.ru
+  Unreloader.require 'app.rb'
+
+  # inside app.rb
+  Unreloader.require 'helpers'
+  Unreloader.record_split_class(__FILE__, 'helpers')
+
+If +app.rb+ is changed or any of the ruby files in +helpers+ is changed,
+it will reload +app.rb+ and all of the files in +helpers+.  This makes
+it so if you remove a method from one of the files in +helpers+, it will
+reload the entire class so that the method is no longer defined.  Likewise,
+if you delete one of the files in helpers, it will reload the class so that
+the methods that were defined in that file will no longer be defined on the
+class.
 
 == Requiring
 
@@ -157,14 +205,14 @@ the directory path:
 
 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.
+automatically. This applies to files in subdirectories of that directory as well.
 
 == 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
+issue as generally 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.
 
@@ -176,6 +224,14 @@ your models just use a capitalized version of the filename:
 
   Unreloader.require('models'){|f| File.basename(f).sub(/\.rb\z/, '').capitalize}
 
+== Usage Outside Rack
+
+While <tt>Rack::Unreloader</tt> 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
+reload the application.
+
 == History
 
 Rack::Unreloader was derived from Padrino's reloader.  It is significantly smaller

data/lib/rack/unreloader.rb

@@ -1,309 +1,50 @@
-require 'set'
+require 'find'
 
 module Rack
   # Reloading application that unloads constants before reloading the relevant
   # files, calling the new rack app if it gets reloaded.
   class Unreloader
-    class Reloader
-      # Reference to ::File as File would return Rack::File by default.
-      F = ::File
-
-      # Regexp for valid constant names, to prevent code execution.
-      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
-
-      # Setup the reloader.  Supports :logger and :subclasses options, see
-      # Rack::Unloader.new for details.
-      def initialize(opts={})
-        @logger = opts[:logger]
-        @classes = opts[:subclasses] ?  Array(opts[:subclasses]).map{|s| s.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).
-        @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.
-        @monitor_dirs = {}
-
-        # 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.
-        @files = {}
-
-        # Similar to @files, but stores previous entries, used when rolling back.
-        @old_entries = {}
-      end
-
-      # Tries to find a declared constant with the name specified
-      # in the string. It raises a NameError when the name is not in CamelCase
-      # or is not initialized.
-      def constantize(s)
-        s = s.to_s
-        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!")
-        end
-      end
-
-      # Log the given string at info level if there is a logger.
-      def log(s)
-        @logger.info(s) if @logger
-      end
-  
-      # If there are any changed files, reload them.  If there are no changed
-      # files, do nothing.
-      def reload!
-        @monitor_dirs.keys.each do |dir|
-          check_monitor_dir(dir)
-        end
-
-        @monitor_files.to_a.each do |file, time|
-          if file_changed?(file, time)
-            safe_load(file)
-          end
-        end
-      end
-
-      # Check a monitored directory for changes, adding new files and removing
-      # deleted files.
-      def check_monitor_dir(dir)
-        time, files, block = @monitor_dirs[dir]
-
-        if file_changed?(dir, time)
-          cur_files = Dir.new(dir).grep(/\.rb\z/).map{|f| F.join(dir, f)}
-
-          (files - cur_files).each do |f|
-            remove(f)
-            @monitor_files.delete(f)
-          end
-
-          require_dependencies(cur_files - files, &block)
-
-          files.replace(cur_files)
-        end
-      end
-
-      # 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)
-        options = {:cyclic => true}
-        error = nil 
-
-        Array(paths).
-          flatten.
-          map{|path| Dir.glob(path).sort_by{|filename| filename.count('/')}}.
-          flatten.
-          map{|path| F.expand_path(path)}.
-          uniq.
-          each do |file|
-
-          if F.directory?(file)
-            @monitor_dirs[file] = [nil, [], block]
-            check_monitor_dir(file)
-            next
-          else
-            @constants_defined[file] = block
-            @monitor_files[file] = nil
-          end
-
-          begin
-            safe_load(file, options)
-          rescue NameError, LoadError => error
-            log "Cyclic dependency reload for #{error}"
-          rescue Exception => error
-            break
-          end
-        end
-
-        if error
-          log error
-          raise error
-        end
-      end
-
-      # Requires the given file, logging which constants or features are added
-      # by the require, and rolling back the constants and features if there
-      # are any errors.
-      def safe_load(file, options={})
-        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
-        begin
-          require(file)
-          commit(file)
-        rescue Exception
-          if !options[:cyclic]
-            log "Failed to load #{file}; removing partially defined constants"
-          end
-          rollback(file)
-          raise
-        end
-      end
-
-      # Removes the specified constant.
-      def remove_constant(const)
-        base, _, object = const.to_s.rpartition('::')
-        base = base.empty? ? Object : constantize(base)
-        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)
-        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
-      # of files to monitor.
-      def clear!
-        @files.keys.each do |file|
-          remove(file)
-        end
-        @monitor_files = {}
-        @old_entries = {}
-      end
-
-      # Remove the given file, removing any constants and other files loaded
-      # by the file.
-      def remove(name)
-        file = @files[name] || return
-        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_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 = {: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)
-        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 |mod|
-          if !mod.name.to_s.empty? && monitored_module?(mod)
-            rs << mod
-          end
-        end
-
-        rs
-      end
-
-      # Return whether the given klass is a monitored class that could
-      # be unloaded.
-      def monitored_module?(mod)
-        @classes.any? do |c|
-          c = constantize(c) rescue false
-
-          if mod.is_a?(Class)
-            # Reload the class if it is a subclass if the current class
-            (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.
-            mod == c
-          end
-        end
-      end
-
-      # Return a set of all classes in the ObjectSpace that are not in the
-      # given set of classes.
-      def new_classes(snapshot)
-        all_classes - snapshot
-      end
+    # Reference to ::File as File would return Rack::File by default.
+    F = ::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}.
+        flatten
+    end
 
-      # Returns true if the file is new or it's modification time changed.
-      def file_changed?(file, time = @monitor_files[file])
-        !time || modified_at(file) > time
-      end
+    # Given the path glob or array of path globs, find all matching files
+    # or directories, and return an array of expanded paths.
+    def self.expand_paths(paths)
+      Array(paths).
+        flatten.
+        map{|path| Dir.glob(path).sort_by{|filename| filename.count('/')}}.
+        flatten.
+        map{|path| F.expand_path(path)}.
+        uniq
+    end
 
-      # Return the time the file was modified at.  This can be overridden
-      # to base the reloading on something other than the file's modification
-      # time.
-      def modified_at(file)
-        F.mtime(file)
+    # The .rb files in the given directory or any subdirectory.
+    def self.ruby_files(dir)
+      files = []
+      Find.find(dir) do |f|
+        files << f if f =~ /\.rb\z/
       end
+      files.sort
     end
 
-    # The Rack::Unreloader::Reloader instead related to this instance.
+    # The Rack::Unreloader::Reloader instead related to this instance, if one.
     attr_reader :reloader
 
     # Setup the reloader. Options:
     # 
     # :cooldown :: The number of seconds to wait between checks for changed files.
-    #              Defaults to 1.
+    #              Defaults to 1.  Set to nil/false to not check for changed files.
+    # :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.
     # :subclasses :: A string or array of strings of class names that should be unloaded.
     #                Any classes that are not subclasses of these classes will not be
@@ -311,25 +52,65 @@ module Rack
     #                match exactly, since modules don't have superclasses.
     def initialize(opts={}, &block)
       @app_block = block
-      @cooldown = opts[:cooldown] || 1
-      @last = Time.at(0)
-      @reloader = Reloader.new(opts)
-      @reloader.reload!
+      if opts.fetch(:reload, true)
+        @cooldown = opts.fetch(:cooldown, 1)
+        @last = Time.at(0)
+        Kernel.require 'rack/unreloader/reloader'
+        @reloader = Reloader.new(opts)
+        reload!
+      else
+        @reloader = @cooldown = false
+      end
     end
 
     # If the cooldown time has been passed, reload any application files that have changed.
     # Call the app with the environment.
     def call(env)
       if @cooldown && Time.now > @last + @cooldown
-        Thread.respond_to?(:exclusive) ? Thread.exclusive{@reloader.reload!} : @reloader.reload!
+        Thread.respond_to?(:exclusive) ? Thread.exclusive{reload!} : reload!
         @last = Time.now
       end
       @app_block.call.call(env)
     end
 
     # Add a file glob or array of file globs to monitor for changes.
-    def require(depends, &block)
-      @reloader.require_dependencies(depends, &block)
+    def require(paths, &block)
+      if @reloader
+        @reloader.require_dependencies(paths, &block)
+      else
+        Unreloader.expand_directory_paths(paths).each{|f| super(f)}
+      end
+    end
+
+    # Records that each path in +files+ depends on +dependency+.  If there
+    # is a modification to +dependency+, all related files will be reloaded
+    # after +dependency+ is reloaded.  Both +dependency+ and each entry in +files+
+    # can be an array of path globs.
+    def record_dependency(dependency, *files)
+      if @reloader
+        files = Unreloader.expand_paths(files)
+        Unreloader.expand_paths(dependency).each do |path|
+          @reloader.record_dependency(path, files)
+        end
+      end
+    end
+
+    # Record that a class is split into multiple files. +main_file+ should be
+    # the main file for the class, which should require all of the other
+    # files.  +files+ should be a list of all other files that make up the class.
+    def record_split_class(main_file, *files)
+      if @reloader
+        files = Unreloader.expand_paths(files)
+        files.each do |file|
+          record_dependency(file, main_file)
+        end
+        @reloader.skip_reload(files)
+      end
+    end
+
+    # Reload the application, checking for changed files and reloading them.
+    def reload!
+      @reloader.reload! if @reloader
     end
   end
 end

data/lib/rack/unreloader/reloader.rb

@@ -0,0 +1,399 @@
+require 'set'
+
+module Rack
+  class Unreloader
+    class Reloader
+      F = ::File
+
+      # Regexp for valid constant names, to prevent code execution.
+      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+
+      # Options hash to force loading of files even if they haven't changed.
+      FORCE = {:force=>true}.freeze
+
+      # Setup the reloader.  Supports :logger and :subclasses options, see
+      # Rack::Unloader.new for details.
+      def initialize(opts={})
+        @logger = opts[:logger]
+        @classes = opts[:subclasses] ?  Array(opts[:subclasses]).map{|s| s.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).
+        @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.
+        @monitor_dirs = {}
+
+        # 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.
+        @files = {}
+
+        # Similar to @files, but stores previous entries, used when rolling back.
+        @old_entries = {}
+
+        # Records dependencies on files.  Keys are absolute paths, values are arrays of absolute paths,
+        # where each entry depends on the key, so that if the key path is modified, all values are
+        # reloaded.
+        @dependencies = {}
+
+        # Array of the order in which to load dependencies
+        @dependency_order = []
+
+        # Array of absolute paths which should be unloaded, but not reloaded on changes,
+        # because files that depend on them will load them automatically.
+        @skip_reload = []
+      end
+
+      # Unload all reloadable constants and features, and clear the list
+      # of files to monitor.
+      def clear!
+        @files.keys.each do |file|
+          remove(file)
+        end
+        @monitor_files = {}
+        @old_entries = {}
+      end
+
+      # Record a dependency the given files, such that each file in +files+
+      # depends on +path+.  If +path+ changes, each file in +files+ should
+      # be reloaded as well.
+      def record_dependency(path, files)
+        files = (@dependencies[path] ||= []).concat(files)
+        files.uniq!
+
+        order = @dependency_order
+        i = order.find_index{|v| files.include?(v)} || -1
+        order.insert(i, path)
+        order.concat(files)
+        order.uniq!
+
+        if F.directory?(path)
+          (@monitor_files.keys & Unreloader.ruby_files(path)).each do |file|
+            record_dependency(file, files)
+          end
+        end
+
+        nil
+      end
+  
+      # If there are any changed files, reload them.  If there are no changed
+      # files, do nothing.
+      def reload!
+        changed_files = []
+
+        @monitor_dirs.keys.each do |dir|
+          check_monitor_dir(dir, changed_files)
+        end
+
+        @monitor_files.each do |file, time|
+          if file_changed?(file, time)
+            changed_files << file
+          end
+        end
+
+        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.flatten!
+          changed_files.uniq!
+          
+          order = @dependency_order
+          order &= changed_files
+          changed_files = order + (changed_files - order)
+        end
+
+        unless @skip_reload.empty?
+          skip_reload = @skip_reload.map{|f| F.directory?(f) ? Unreloader.ruby_files(f) : f}
+          skip_reload.flatten!
+          skip_reload.uniq!
+          changed_files -= skip_reload
+        end
+
+        changed_files.each do |file|
+          safe_load(file, FORCE)
+        end
+      end
+
+      # 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)
+        options = {:cyclic => true}
+        error = nil 
+
+        Unreloader.expand_paths(paths).each do |file|
+          if F.directory?(file)
+            @monitor_dirs[file] = [nil, [], block]
+            check_monitor_dir(file)
+            next
+          else
+            @constants_defined[file] = block
+            @monitor_files[file] = nil
+          end
+
+          begin
+            safe_load(file, options)
+          rescue NameError, LoadError => error
+            log "Cyclic dependency reload for #{error}"
+          rescue Exception => error
+            break
+          end
+        end
+
+        if error
+          log error
+          raise error
+        end
+      end
+
+      # Skip reloading the given files.  Should only be used if other files
+      # depend on these files and the other files require these files when
+      # loaded.
+      def skip_reload(files)
+        @skip_reload.concat(files)
+        @skip_reload.uniq!
+        nil
+      end
+
+      private
+
+      # Tries to find a declared constant with the name specified
+      # in the string. It raises a NameError when the name is not in CamelCase
+      # or is not initialized.
+      def constantize(s)
+        s = s.to_s
+        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!")
+        end
+      end
+
+      # Log the given string at info level if there is a logger.
+      def log(s)
+        @logger.info(s) if @logger
+      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]
+
+        cur_files = Unreloader.ruby_files(dir)
+        return if files == cur_files
+
+        removed_files = files - cur_files
+        new_files = cur_files - files
+
+        if changed_files
+          changed_files.concat(dependency_files(removed_files))
+        end
+
+        removed_files.each do |f|
+          remove(f)
+          @monitor_files.delete(f)
+          @dependencies.delete(f)
+          @dependency_order.delete(f)
+        end
+
+        require_dependencies(new_files, &block)
+
+        new_files.each do |file|
+          if deps = @dependencies[dir]
+            record_dependency(file, deps)
+          end
+        end
+
+        if changed_files
+          changed_files.concat(dependency_files(new_files))
+        end
+
+        files.replace(cur_files)
+      end
+
+      # Requires the given file, logging which constants or features are added
+      # by the require, and rolling back the constants and features if there
+      # are any errors.
+      def safe_load(file, options={})
+        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
+        begin
+          require(file)
+          commit(file)
+        rescue Exception
+          if !options[:cyclic]
+            log "Failed to load #{file}; removing partially defined constants"
+          end
+          rollback(file)
+          raise
+        end
+      end
+
+      # Removes the specified constant.
+      def remove_constant(const)
+        base, _, object = const.to_s.rpartition('::')
+        base = base.empty? ? Object : constantize(base)
+        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)
+        if @monitor_files.has_key?(file)
+          $LOADED_FEATURES.delete(file)
+          log "Removed feature #{file}"
+        end
+      end
+
+      # Remove the given file, removing any constants and other files loaded
+      # by the file.
+      def remove(name)
+        file = @files[name] || return
+        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_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 = {: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)
+        remove_constants(name){new_classes(@old_entries[name][:constants])}
+        @old_entries.delete(name)
+      end
+
+      # 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 |mod|
+          if !mod.name.to_s.empty? && monitored_module?(mod)
+            rs << mod
+          end
+        end
+
+        rs
+      end
+
+      # Return whether the given klass is a monitored class that could
+      # be unloaded.
+      def monitored_module?(mod)
+        @classes.any? do |c|
+          c = constantize(c) rescue false
+
+          if mod.is_a?(Class)
+            # Reload the class if it is a subclass if the current class
+            (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.
+            mod == c
+          end
+        end
+      end
+
+      # Recursively reload dependencies for the changed files.
+      def reload_files(changed_files)
+        changed_files.map do |file|
+          if deps = @dependencies[file]
+            [file] + reload_files(deps)
+          else
+            file
+          end
+        end
+      end
+
+      # The dependencies for the changed files, excluding the files themselves.
+      def dependency_files(changed_files)
+        files = reload_files(changed_files)
+        files.flatten!
+        files - changed_files
+      end
+
+      # Return a set of all classes in the ObjectSpace that are not in the
+      # given set of classes.
+      def new_classes(snapshot)
+        all_classes - snapshot
+      end
+
+      # Returns true if the file is new or it's modification time changed.
+      def file_changed?(file, time = @monitor_files[file])
+        !time || modified_at(file) > time
+      end
+
+      # Return the time the file was modified at.  This can be overridden
+      # to base the reloading on something other than the file's modification
+      # time.
+      def modified_at(file)
+        F.mtime(file)
+      end
+    end
+  end
+end

data/spec/unreloader_spec.rb

@@ -33,7 +33,7 @@ describe Rack::Unreloader do
   end
 
   def update_app(code, file=@filename)
-    ru.reloader.set_modified_time(file, @i += 1)
+    ru.reloader.set_modified_time(file, @i += 1) if ru.reloader
     File.open(file, 'wb'){|f| f.write(code)}
   end
 
@@ -49,7 +49,7 @@ describe Rack::Unreloader do
   def base_ru(opts={})
     block = opts[:block] || proc{App}
     @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
-    @ru.reloader.extend ModifiedAt
+    @ru.reloader.extend ModifiedAt if @ru.reloader
     Object.const_set(:RU, @ru)
   end
 
@@ -57,7 +57,7 @@ describe Rack::Unreloader do
     return @ru if @ru
     base_ru(opts)
     update_app(opts[:code]||code(1))
-    @ru.require 'spec/app.rb'
+    @ru.require @filename
     @ru
   end
 
@@ -72,13 +72,30 @@ describe Rack::Unreloader do
   end
 
   after do
-    ru.reloader.clear!
+    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({}).should == [1]
+    update_app(code(2))
+    ru.call({}).should == [1]
+    @ru.reload!
+    ru.call({}).should == [2]
+  end
+
+  it "should not setup a reloader if reload option is false" do
+    @filename = 'spec/app_no_reload.rb'
+    ru(:reload => false).call({}).should == [1]
+    file = 'spec/app_no_reload2.rb'
+    File.open(file, 'wb'){|f| f.write('ANR2 = 2')}
+    ru.require 'spec/app_no_*2.rb'
+    ANR2.should == 2
+  end
+
   it "should unload constants contained in file and reload file if file changes" do
     ru.call({}).should == [1]
     update_app(code(2))
@@ -268,16 +285,113 @@ describe Rack::Unreloader do
               %r{\ARemoved feature .*/spec/app.rb\z}
   end
 
+  it "should handle recorded dependencies" 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({}).should == 1
+    update_app("module A; B = 2; end", 'spec/app_mod.rb')
+    ru.call({}).should == 2
+    update_app("module A; include C; end", 'spec/app_mod.rb')
+    update_app("module C; B = 3; end", 'spec/app_mod2.rb')
+    ru.record_dependency 'spec/app_mod2.rb', 'spec/app_mod.rb'
+    ru.require 'spec/app_mod2.rb'
+    ru.call({}).should == 3
+    update_app("module C; B = 4; end", 'spec/app_mod2.rb')
+    ru.call({}).should == 4
+  end
+
   describe "with a directory" do
-    before do
+    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)}
+      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 have unreloader require with directories if reload option is false" do
+      file = 'spec/dir/app_no_reload3.rb'
+      File.open(file, 'wb'){|f| f.write('ANR3 = 3')}
+      base_ru(:reload => false)
+      ru.require 'spec/dir'
+      ANR3.should == 3
+    end
+
+    it "should handle recorded dependencies in directories" 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({}).should == 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).should == 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.require 'spec/dir/subdir2/app_mod2.rb'
+      ru.record_dependency 'spec/dir/subdir2/app_mod2.rb', 'spec/dir/subdir'
+      ru.call({}).should == 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).should == 4
+    end
+
+    it "should handle recorded dependencies in directories when files are added or removed later" 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({}).should == 0
+      update_app("module A; B = 1; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).should == 1
+      update_app("module A; B = 2; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).should == 2
+      update_app("module C; B = 3; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).should == 2
+      update_app("module A; include C; end", 'spec/dir/subdir/app_mod.rb')
+      ru.call({}).should == 3
+      update_app("module C; B = 4; end", 'spec/dir/subdir2/app_mod2.rb')
+      ru.call({}).should == 4
+      File.delete 'spec/dir/subdir/app_mod.rb'
+      ru.call({}).should == 0
+    end
+
+    it "should handle classes split into multiple files" 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({}).should == 1
+      update_app("class App; def self.a; 2 end end", 'spec/dir/appa.rb')
+      ru.call({}).should == 21
+      update_app("class App; def self.a; 3 end end", 'spec/dir/appa.rb')
+      ru.call({}).should == 31
+      update_app("class App; def self.b; 4 end end", 'spec/dir/appb.rb')
+      ru.call({}).should == 341
+      update_app("class App; def self.a; 5 end end", 'spec/dir/appa.rb')
+      update_app("class App; def self.b; 6 end end", 'spec/dir/appb.rb')
+      ru.call({}).should == 561
+      update_app("class App; end", 'spec/dir/appa.rb')
+      ru.call({}).should == 61
+      File.delete 'spec/dir/appb.rb'
+      ru.call({}).should == 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'")
@@ -294,6 +408,22 @@ describe Rack::Unreloader do
                 %r{\ARemoved feature .*/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({}).should == {:foo=>1}
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
+      ru.call({}).should == {: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{\AReloading .*/spec/dir/subdir/a.rb\z},
+                %r{\ARemoved feature .*/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'")
@@ -306,6 +436,18 @@ describe Rack::Unreloader do
                 %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({}).should == {}
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/a.rb')
+      ru.call({}).should == {: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'")
@@ -322,5 +464,22 @@ describe Rack::Unreloader do
                 %r{\ARemoved feature .*/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({}).should == {:foo=>1}
+      File.delete('spec/dir/subdir/a.rb')
+      update_app("App.call[:foo] = 2", 'spec/dir/subdir/b.rb')
+      ru.call({}).should == {:foo=>2}
+      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{\ARemoved feature .*/spec/dir/subdir/a.rb\z},
+                %r{\ALoading.*spec/dir/subdir/b\.rb\z}
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2015-01-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   Rack::Unreloader is a rack middleware that reloads application files when it
@@ -26,6 +26,7 @@ files:
 - README.rdoc
 - Rakefile
 - lib/rack/unreloader.rb
+- lib/rack/unreloader/reloader.rb
 - spec/unreloader_spec.rb
 homepage: http://gihub.com/jeremyevans/rack-unreloader
 licenses:
@@ -54,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Reload application when files change, unloading constants first