rails-dev-boost 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c6be77bb649766e7ae7bfe30a7d45f848c62ec3
+  data.tar.gz: 380d7b77ab210ea426ee7a4369e46102e317bb5b
+SHA512:
+  metadata.gz: e69c5b78346a397e7bc99069e323db29ea92dd3ced9cd2da58d3083e7fb625be6075c3482e85bccece82390bf681cf24e3615dee5b0c2b211a8cfcf86ec650e7
+  data.tar.gz: e4d005306b5d46d9f668cc241d8a9dfc735a51447da2f13cf6c6aaad97ab1f19580b997b0db78fe6308bc64af60f8ea80a002305153198d7c5562ae29fc37435

data/README.markdown

@@ -8,7 +8,7 @@ Alternative to Robert Pankowecki's [`active_reload`](https://github.com/paneq/ac
 
 ## Branches
 
-If you are using **Rails 3**: [`rails-dev-boost/master`](http://github.com/thedarkone/rails-dev-boost/tree/master) branch.
+If you are using **Rails 3 and newer**: [`rails-dev-boost/master`](http://github.com/thedarkone/rails-dev-boost/tree/master) branch.
 
 If you are using **Rails 2.3**: [`rails-dev-boost/rails-2-3`](http://github.com/thedarkone/rails-dev-boost/tree/rails-2-3) branch.
 
@@ -29,7 +29,7 @@ I'm very interested in making the plugin as robust as possible and will work wit
 
 There is built-in debug mode in `rails-dev-boost` that can be enabled by putting this line a Rails initializer file:
 
-    RailsDevelopmentBoost.debug!
+    RailsDevelopmentBoost.debug! if defined?(RailsDevelopmentBoost)
 
 After restarting your server `rails-dev-boost` will start to spewing detailed tracing information about its actions into your `development.log` file.
 
@@ -47,7 +47,7 @@ Usage through `Gemfile`:
 
 ```ruby
 group :development do
-  gem 'rails-dev-boost', :git => 'git://github.com/thedarkone/rails-dev-boost.git', :require => 'rails_development_boost'
+  gem 'rails-dev-boost', :git => 'git://github.com/thedarkone/rails-dev-boost.git'
 end
 ```
 
@@ -279,6 +279,24 @@ class Blog < ActiveRecord::Base
 end
 ```
 
+## Asynchronous mode
+
+By default `rails-dev-boost` now runs in an "async" mode, watching and unloading modified files in a separate thread. This allows for an even faster development mode because there is no longer a need to do a `File.mtime` check of all the `.rb` files at the beginning of the request.
+
+To disable the async mode put the following code in a Rails initializer file (these are found in `config/initializers` directory):
+```ruby
+RailsDevelopmentBoost.async = false
+```
+
+## `routes.rb` potentially not reloading
+
+Since Rails 4.0 `ActiveSupport` now by default reloads `routes.rb` file **if any other auto-loaded `.rb` has changed**. This behavior is different from all previous Rails versions, where `routes.rb` had been reloaded **only if the `routes.rb` file itself had been changed**. This now results in `routes.rb` being reloading on all requests in which any other unrelated `.rb` has been changed, it is in my opinion an unnecessary slowdown, thus `rails-dev-boost` by default reverts Rails to the pre Rails 4.0 behavior.
+
+To disable this patch and revert to the default Rails 4.0 behavior - put the following code in a Rails initializer file (these are found in `config/initializers` directory):
+```ruby
+RailsDevelopmentBoost.reload_routes_on_any_change = true
+```
+
 ## FAQ
 
 ### Q: Since the plugin uses its special "unloading mechanism" won't everything break down?

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/lib/rails_development_boost.rb

@@ -13,6 +13,8 @@ module RailsDevelopmentBoost
         else
           ActionDispatch::Callbacks.before(:prepend => true)    { ActiveSupport::Dependencies.unload_modified_files! }
         end
+        
+        DependenciesPatch.enable_async_mode_by_default!
       end
     end
     
@@ -35,6 +37,8 @@ module RailsDevelopmentBoost
         else
           ActiveSupport.on_load(:action_controller) { ViewHelpersPatch.apply! }
         end
+        
+        app.config.middleware.use 'RailsDevelopmentBoost::Async::Middleware'
       end
     end
   end
@@ -55,7 +59,12 @@ module RailsDevelopmentBoost
     DependenciesPatch.debug!
   end
   
-  def self.async!
-    DependenciesPatch.async!
+  def self.async=(new_value)
+    DependenciesPatch.async = new_value
+  end
+  
+  class << self
+    attr_accessor :reload_routes_on_any_change
   end
+  self.reload_routes_on_any_change = false
 end

data/lib/rails_development_boost/async.rb

@@ -1,15 +1,29 @@
-require 'rb-fsevent'
 require 'monitor'
 
 module RailsDevelopmentBoost
   module Async
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        if DependenciesPatch.applied? && DependenciesPatch.async?
+          Async.synchronize { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      end
+    end
+    
     extend self
+    autoload :Reactor, 'rails_development_boost/async/reactor'
     
     MONITOR = Monitor.new
     
     def heartbeat_check!
       if @reactor
-        unless @reactor.alive?
+        unless @reactor.alive_and_watching?(ActiveSupport::Dependencies.autoload_paths)
           @reactor.stop
           @reactor = nil
           start!
@@ -25,13 +39,56 @@ module RailsDevelopmentBoost
       MONITOR.synchronize { yield }
     end
     
+    def usable?
+      Reactor.implementation
+    end
+    
+    def process_new_async_value(new_value)
+      if new_value
+        if !Async.usable?
+          msg = 'Unable to start rails-dev-boost in an asynchronous mode. '
+          if gem_error = Reactor.gem_load_error
+            msg << "Please install the missing gem for even faster rails-dev-boost experience:\n#{gem_error}\n" <<
+                   "If you can't use the suggest gem version please let me know at https://github.com/thedarkone/rails-dev-boost/issues !\n"
+          else
+            msg << "Are you running on a OS that is 'async-unsupported' by rails-dev-boost? Please open an issue on github: https://github.com/thedarkone/rails-dev-boost/issues !"
+          end
+          msg << "\nTo get rid of this message disable the rails-dev-boost's async mode by putting the following code " +
+                 "in a Rails initializer file (these are found in config/initializers directory):\n" +
+                 "\n\tRailsDevelopmentBoost.async = false if defined?(RailsDevelopmentBoost)\n\n"
+          async_warning(msg)
+          new_value = false
+        elsif in_console?
+          async_warning('Warning: using asynchronous mode in Rails console mode might result in surprising behaviour and is not recommended.')
+        end
+      end
+      new_value
+    end
+    
+    def enable_by_default!(user_provided_value = false)
+      unless user_provided_value
+        DependenciesPatch.async = true unless usable? # trigger the warning message, unless there is a user supplied `async` setting
+        DependenciesPatch.async = !in_console?
+      end
+    end
+    
     private
+    def in_console?
+      defined?(IRB) || defined?(Pry)
+    end
+    
+    def async_warning(msg)
+      msg = msg.gsub(/^/, '[RAILS-DEV-BOOST] ')
+      Kernel.warn(msg)
+      Rails.logger.info(msg)
+    end
     
     def start!
-      @reactor = Reactor.new
-      @reactor.watch(ActiveSupport::Dependencies.autoload_paths) {|changed_dirs| unload_affected(changed_dirs)}
-      @reactor.start!
-      self.unloaded_something = LoadedFile.unload_modified! # don't miss-out on any of the file changes as the async thread hasn't been started as of yet
+      if @reactor = Reactor.get
+        @reactor.watch(ActiveSupport::Dependencies.autoload_paths) {|changed_dirs| unload_affected(changed_dirs)}
+        @reactor.start!
+        self.unloaded_something = LoadedFile.unload_modified! # don't miss-out on any of the file changes as the async thread hasn't been started as of yet
+      end
     end
     
     def re_raise_unload_error_if_any
@@ -45,9 +102,7 @@ module RailsDevelopmentBoost
       changed_dirs = changed_dirs.map {|changed_dir| File.expand_path(changed_dir).chomp(File::SEPARATOR)}
       
       synchronize do
-        self.unloaded_something = LoadedFile::LOADED.each_file_unload_if_changed do |file|
-          changed_dirs.any? {|changed_dir| file.path.starts_with?(changed_dir)} && file.changed?
-        end
+        self.unloaded_something = LoadedFile::LOADED.unload_modified!(changed_dirs)
       end
     rescue Exception => e
       @unload_error ||= e
@@ -56,18 +111,5 @@ module RailsDevelopmentBoost
     def unloaded_something=(value)
       @unloaded_something ||= value
     end
-    
-    class Reactor
-      delegate :alive?, :to => '@thread'
-      delegate :watch, :stop, :to => '@watcher'
-      
-      def initialize
-        @watcher = FSEvent.new
-      end
-      
-      def start!
-        @thread = Thread.new { @watcher.run }
-      end
-    end
   end
 end

data/lib/rails_development_boost/async/reactor.rb

@@ -0,0 +1,195 @@
+require 'thread'
+require 'set'
+
+module RailsDevelopmentBoost
+  module Async
+    # Not using Listen gem directly, because I don't want to be storing/checking .rb files' SHA contents and would like to rely on mtime values exclusively.
+    module Reactor
+      class MissingNativeGem < StandardError
+        def initialize(gem_name, version)
+          gem_version_msg = indented_code("gem '#{gem_name}', '#{version}'")
+          super("by adding the following to your Gemfile:\n#{gem_version_msg}\n\nThis can go into the same :development group if (you are using one):\n" <<
+                indented_code("group :development do\n\tgem 'rails-dev-boost', :github => 'thedarkone/rails-dev-boost'#{gem_version_msg}\nend\n"))
+        end
+        
+        private
+        def indented_code(msg)
+          "\n\t" << msg.gsub("\n", "\n\t")
+        end
+      end
+      
+      extend self
+      attr_reader :gem_load_error
+      
+      def get
+        if impl = implementation
+          impl.new
+        end
+      end
+      
+      def implementation
+        defined?(@implementation) ? @implementation : (@implementation = find_usable_implementation)
+      end
+      
+      def find_usable_implementation
+        [Darwin, Linux, Windows].find(&:usable?)
+      rescue MissingNativeGem => e
+        @gem_load_error ||= e.message
+        nil
+      end
+      
+      class Base
+        def initialize
+          @watcher     = create_watcher
+          @directories = Set.new
+        end
+        
+        def watch(directories, &block)
+          @directories.merge(directories)
+          watch_internal(directories, &block)
+        end
+
+        def start!
+          @thread = Thread.new { start_watcher! }
+        end
+        
+        def stop
+          @watcher.stop
+          stop_thread
+        end
+        
+        def alive_and_watching?(directories)
+          @thread.alive? && directories.all? {|directory| @directories.include?(directory)}
+        end
+        
+        private
+        def watch_internal(directories, &block)
+          @watcher.watch(directories, &block)
+        end
+        
+        def stop_thread
+          @thread.join if @thread
+        end
+        
+        def start_watcher!
+          @watcher.run
+        end
+        
+        class << self
+          def usable?
+            gem_check! if platform_match?
+          end
+          
+          private
+          def platform_match?
+            require 'rbconfig'
+            RbConfig::CONFIG['target_os'] =~ self::TARGET_OS_REGEX
+          end
+          
+          def gem_check!
+            defined?(@gem_loaded) ? @gem_loaded : @gem_loaded = load_gem!
+          end
+          
+          def load_gem!
+            gem(self::GEM_NAME, self::GEM_VERSION)
+            require(self::GEM_NAME)
+            true
+          rescue Gem::LoadError
+            raise MissingNativeGem.new(self::GEM_NAME, self::GEM_VERSION)
+          end
+        end
+      end
+
+      class Darwin < Base
+        TARGET_OS_REGEX = /darwin(1.+)?$/i
+        GEM_NAME        = 'rb-fsevent'
+        GEM_VERSION     = '>= 0.9.1'
+        
+        private
+        def create_watcher
+          FSEvent.new
+        end
+      end
+
+      # Errors, comments and other gotchas taken from Listen gem (https://github.com/guard/listen)
+      class Linux < Base
+        TARGET_OS_REGEX = /linux/i
+        GEM_NAME        = 'rb-inotify'
+        GEM_VERSION     = '>= 0.8.8'
+        
+        EVENTS = [:recursive, :attrib, :create, :delete, :move, :close_write]
+        
+        # The message to show when the limit of inotify watchers is not enough
+        #
+        INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+          Listen error: unable to monitor directories for changes.
+
+          Please head to https://github.com/guard/listen/wiki/Increasing-the-amount-of-inotify-watchers
+          for information on how to solve this issue.
+        EOS
+        
+        private
+        def watch_internal(directories)
+          directories.each do |directory|
+            @watcher.watch(directory, *EVENTS) do |event|
+              unless root?(event) || file_event_on_a_dir?(event)
+                if File.file?(absolute_name = event.absolute_name)
+                  yield [File.dirname(absolute_name)]
+                elsif File.directory?(absolute_name)
+                  yield [absolute_name]
+                end
+              end
+            end
+          end
+        rescue Errno::ENOSPC
+          abort(INOTIFY_LIMIT_MESSAGE)
+        end
+        
+        def root?(event) # Event on root directory
+          event.name.empty? # same as event.name == ""
+        end
+        
+        # INotify reports changes to files inside directories as events
+        # on the directories themselves too.
+        #
+        # @see http://linux.die.net/man/7/inotify
+        def file_event_on_a_dir?(event)
+          # event.flags.include?(:isdir) and event.flags & [:close, :modify] != []
+          flags = event.flags
+          flags.include?(:isdir) && (flags.include?(:close) || flags.include?(:modify))
+        end
+        
+        def create_watcher
+          INotify::Notifier.new
+        end
+        
+        def stop_thread
+          Thread.kill(@thread) if @thread
+        end
+      end
+      
+      class Windows < Base
+        TARGET_OS_REGEX = /mswin|mingw|cygwin/i
+        GEM_NAME        = 'wdm'
+        GEM_VERSION     = '>= 0.0.3'
+        
+        private
+        def watch_internal(directories)
+          directories.each do |directory|
+            @watcher.watch_recursively(directory) do |change|
+              yield [File.dirname(change.path)]
+            end
+          end
+        end
+        
+        def create_watcher
+          WDM::Monitor.new
+        end
+        
+        def start_watcher!
+          @watcher.run!
+        end
+      end
+    end
+  end
+end

data/lib/rails_development_boost/dependencies_patch.rb

@@ -18,13 +18,22 @@ module RailsDevelopmentBoost
       
       patch = self
       ActiveSupport::Dependencies.module_eval do
-        alias_method :local_const_defined?, :uninherited_const_defined? unless method_defined?(:local_const_defined?) # pre 4da45060 compatibility
+        unless method_defined?(:local_const_defined?) # pre 4da45060 compatibility
+          if method_defined?(:uninherited_const_defined?)
+            alias_method :local_const_defined?, :uninherited_const_defined?
+          else # post 4.0 compat
+            def local_const_defined?(mod, const_name)
+              mod.const_defined?(const_name, false)
+            end
+          end
+        end
         remove_possible_method :remove_unloadable_constants!
         remove_possible_method :clear
         include patch
         alias_method_chain :load_file, 'constant_tracking'
         alias_method_chain :remove_constant, 'handling_of_connections'
         extend patch
+        @routes_path_loading = nil
       end
       
       ActiveSupport::Dependencies::Loadable.module_eval do
@@ -45,23 +54,24 @@ module RailsDevelopmentBoost
       end
     end
     
-    def self.async!
-      @async = true
+    def self.async=(new_value)
+      @async = Async.process_new_async_value(new_value)
     end
     
     def self.async?
       @async
     end
     
+    def self.enable_async_mode_by_default!
+      Async.enable_by_default!(defined?(@async))
+    end
+    
     def self.applied?
       ActiveSupport::Dependencies < self
     end
     
     autoload :InstrumentationPatch, 'rails_development_boost/dependencies_patch/instrumentation_patch'
   
-    mattr_accessor :constants_being_removed
-    self.constants_being_removed = []
-    
     mattr_accessor :explicit_dependencies
     self.explicit_dependencies = {}
     
@@ -91,6 +101,12 @@ module RailsDevelopmentBoost
         end while const_name.sub!(/::[^:]+\Z/, NOTHING)
         false
       end
+      
+      def load_path_to_real_path(path)
+        expanded_path = File.expand_path(path)
+        expanded_path << '.rb' unless path =~ /\.r(?:b|ake)\Z/
+        expanded_path
+      end
     end
     
     class ModuleCache
@@ -154,12 +170,50 @@ module RailsDevelopmentBoost
       end
     end
     
+    class ConstantsHeap < Array
+      NAMESPACE_SEPARATOR = '::'
+      
+      def initialize(*args)
+        super
+        @seen = Set.new
+      end
+      
+      def add_const?(const_name, force_insert = false)
+        if @seen.add?(const_name) || force_insert
+          (self[const_name.count(NAMESPACE_SEPARATOR)] ||= []) << const_name
+          true
+        else
+          false
+        end
+      end
+      
+      def pop_next_const
+        reverse_each do |slot|
+          if const_name = slot.try(:pop)
+            return const_name
+          end
+        end
+        nil
+      end
+      
+      def seen?(const_name)
+        @seen.include?(const_name)
+      end
+      
+      def clear_seen
+        @seen.clear
+      end
+    end
+    
+    mattr_accessor :constants_to_remove
+    self.constants_to_remove = ConstantsHeap.new
+    
     def unload_modified_files!
-      unloaded_something = unload_modified_files_internal!
-      load_failure       = clear_load_failure
-      unloaded_something || load_failure
-    ensure
-      async_synchronize { @module_cache = nil }
+      async_synchronize do
+        unloaded_something = unload_modified_files_internal!
+        load_failure       = clear_load_failure
+        unloaded_something || load_failure
+      end
     end
     
     def remove_explicitely_unloadable_constants!
@@ -173,7 +227,10 @@ module RailsDevelopmentBoost
     # Augmented `load_file'.
     def load_file_with_constant_tracking(path, *args)
       async_synchronize do
-        @module_cache = nil # nuking the module_cache helps to avoid any stale-class issues when the async mode is used in a console session
+        if @module_cache
+          @module_cache = nil
+          constants_to_remove.clear_seen
+        end
         load_file_with_constant_tracking_internal(path, args)
       end
     end
@@ -187,6 +244,14 @@ module RailsDevelopmentBoost
       currently_loading.pop
     end
     
+    def loading_routes_file(path)
+      prev_value = @routes_path_loading
+      @routes_path_loading = Util.load_path_to_real_path(path)
+      yield
+    ensure
+      @routes_path_loading = prev_value
+    end
+    
     def associate_constants_to_file(constants, file_path)
       # freezing strings before using them as Hash keys is slightly more memory efficient
       constants.map!(&:freeze)
@@ -195,13 +260,32 @@ module RailsDevelopmentBoost
       LoadedFile.for(file_path).add_constants(constants)
     end
     
+    def schedule_const_for_unloading(const_name)
+      if constants_to_remove.add_const?(const_name)
+        if qualified_const_defined?(const_name) && object = const_name.constantize
+          @module_cache ||= ModuleCache.new # make sure module_cache has been created
+          schedule_dependent_constants_for_removal(const_name, object)
+        end
+        true
+      end
+    end
+    
+    def process_consts_scheduled_for_removal
+      unless @now_removing_const
+        @now_removing_const = true
+        begin
+          process_consts_scheduled_for_removal_internal
+        ensure
+          @now_removing_const = nil
+        end
+      end
+    end
+    
     # Augmented `remove_constant'.
     def remove_constant_with_handling_of_connections(const_name)
       async_synchronize do
-        module_cache # make sure module_cache has been created
-        prevent_further_removal_of(const_name) do
-          unprotected_remove_constant(const_name)
-        end
+        schedule_const_for_unloading(const_name)
+        process_consts_scheduled_for_removal
       end
     end
     
@@ -247,6 +331,20 @@ module RailsDevelopmentBoost
     end
     
   private
+    def process_consts_scheduled_for_removal_internal
+      heap   = constants_to_remove
+      result = nil
+      while const_to_remove = heap.pop_next_const
+        begin
+          result = unprotected_remove_constant(const_to_remove, qualified_const_defined?(const_to_remove) && const_to_remove.constantize)
+        rescue Exception
+          heap.add_const?(const_to_remove, true)
+          raise
+        end
+      end
+      result
+    end
+  
     def unload_modified_files_internal!
       log_call
       if DependenciesPatch.async?
@@ -270,6 +368,9 @@ module RailsDevelopmentBoost
       
         # Associate newly loaded constants to the file just loaded
         associate_constants_to_file(new_constants, path)
+        if routes_path_loading = @routes_path_loading
+          RoutesLoadedFile.for(routes_path_loading).associate_with(LoadedFile.for(path))
+        end
       end
 
       result
@@ -282,16 +383,17 @@ module RailsDevelopmentBoost
         yield
       end
     end
-  
-    def unprotected_remove_constant(const_name)
-      if qualified_const_defined?(const_name) && object = const_name.constantize
-        handle_connected_constants(object, const_name)
-        LoadedFile.unload_files_with_const!(const_name)
-        if object.kind_of?(Module)
-          remove_parent_modules_if_autoloaded(object)
-          remove_child_module_constants(object, const_name)
-        end
+    
+    def schedule_dependent_constants_for_removal(const_name, object)
+      handle_connected_constants(object, const_name)
+      LoadedFile.schedule_for_unloading_files_with_const!(const_name)
+      if object.kind_of?(Module)
+        remove_parent_modules_if_autoloaded(object)
+        remove_child_module_constants(object, const_name)
       end
+    end
+  
+    def unprotected_remove_constant(const_name, object)
       result = remove_constant_without_handling_of_connections(const_name)
       clear_tracks_of_removed_const(const_name, object)
       result
@@ -299,17 +401,19 @@ module RailsDevelopmentBoost
   
     def error_loading_file(file_path, e)
       LoadedFile.for(file_path).stale! if LoadedFile.loaded?(file_path)
-      @load_failure = true
+      # only the errors that blow through the full stack are load failures, this lets user code handle failed load failures by rescuing raised exceptions without triggering a full dependecies reload
+      @load_failure = true if currently_loading.size == 1
       raise e
     end
     
     def handle_connected_constants(object, const_name)
       return unless Module === object && qualified_const_defined?(const_name)
+      remove_nested_constants(const_name)
       remove_explicit_dependencies_of(const_name)
       remove_dependent_modules(object)
+      # TODO move these into the cleanup phase
       update_activerecord_related_references(object)
       update_mongoid_related_references(object)
-      remove_nested_constants(const_name)
     end
     
     def remove_nested_constants(const_name)
@@ -317,7 +421,7 @@ module RailsDevelopmentBoost
     end
     
     def remove_nested_constant(parent_const, child_const)
-      remove_constant(child_const)
+      schedule_const_for_unloading(child_const)
     end
     
     # AS::Dependencies doesn't track same-file nested constants, so we need to look out for them on our own.
@@ -339,7 +443,7 @@ module RailsDevelopmentBoost
     end
     
     def remove_autoloaded_parent_module(initial_object, parent_object)
-      remove_constant(parent_object._mod_name)
+      schedule_const_for_unloading(parent_object._mod_name)
     end
     
     def autoloaded_object?(object) # faster than going through Dependencies.autoloaded?
@@ -373,7 +477,7 @@ module RailsDevelopmentBoost
     end
     
     def remove_child_module_constant(parent_object, full_child_const_name)
-      remove_constant(full_child_const_name)
+      schedule_const_for_unloading(full_child_const_name)
     end
     
     def remove_explicit_dependencies_of(const_name)
@@ -385,21 +489,23 @@ module RailsDevelopmentBoost
     end
     
     def remove_explicit_dependency(const_name, depending_const)
-      remove_constant(depending_const)
+      schedule_const_for_unloading(depending_const)
     end
     
     def clear_tracks_of_removed_const(const_name, object = nil)
       autoloaded_constants.delete(const_name)
-      @module_cache.remove_const(const_name, object)
+      # @module_cache might be nil if remove_constant has been called with a non-existent constant, ie: it hasn't been checked with `qualified_const_defined?`. Because AS::Dep doesn't blow, neither
+      # should we.
+      @module_cache.remove_const(const_name, object) if @module_cache
       LoadedFile.const_unloaded(const_name)
     end
     
     def remove_dependent_modules(mod)
-      module_cache.each_dependent_on(mod) {|other| remove_dependent_constant(mod, other)}
+      @module_cache.each_dependent_on(mod) {|other| remove_dependent_constant(mod, other)}
     end
     
     def remove_dependent_constant(original_module, dependent_module)
-      remove_constant(dependent_module._mod_name)
+      schedule_const_for_unloading(dependent_module._mod_name)
     end
     
     AR_REFLECTION_CACHES = [:@klass]
@@ -419,10 +525,10 @@ module RailsDevelopmentBoost
     def update_mongoid_related_references(klass)
       if defined?(Mongoid::Document) && klass < Mongoid::Document
         while (superclass = Util.first_non_anonymous_superclass(superclass || klass)) != Object && superclass < Mongoid::Document
-          remove_constant(superclass._mod_name) # this is necessary to nuke the @_types caches
+          schedule_const_for_unloading(superclass._mod_name) # this is necessary to nuke the @_types caches
         end
         
-        module_cache.each_dependent_on(Mongoid::Document) do |model|
+        @module_cache.each_dependent_on(Mongoid::Document) do |model|
           clean_up_relation_caches(model.relations, klass, MONGOID_RELATION_CACHES)
         end
       end
@@ -435,20 +541,5 @@ module RailsDevelopmentBoost
         end
       end
     end
-    
-    def module_cache
-      @module_cache ||= ModuleCache.new
-    end
-
-    def prevent_further_removal_of(const_name)
-      return if constants_being_removed.include?(const_name)
-      
-      constants_being_removed << const_name
-      begin
-        yield
-      ensure
-        constants_being_removed.delete(const_name)
-      end
-    end
   end
 end

data/lib/rails_development_boost/dependencies_patch/instrumentation_patch.rb

@@ -2,7 +2,7 @@ module RailsDevelopmentBoost
   module DependenciesPatch
     module InstrumentationPatch
       module Instrumenter
-        delegate :boost_log, :to => 'ActiveSupport::Dependencies'
+        delegate :boost_log, :boost_log_nested, :boost_log_schedule_const_removal, :to => 'ActiveSupport::Dependencies'
         
         def self.included(mod)
           mod.extend(ClassMethods)
@@ -38,9 +38,14 @@ module RailsDevelopmentBoost
           add_constants_without_instrumentation(new_constants)
         end
         
-        def unload_dependent_file_with_instrumentation(dependent_file)
-          boost_log('UNLOAD_DEPENDENT', "#{boost_inspect}: #{dependent_file.boost_inspect}")
-          unload_dependent_file_without_instrumentation(dependent_file)
+        def dependent_file_schedule_for_unloading_with_instrumentation!(dependent_file)
+          boost_log('SCHEDULE_DEPENDENT', "#{boost_inspect}: #{dependent_file.boost_inspect}")
+          dependent_file_schedule_for_unloading_without_instrumentation!(dependent_file)
+        end
+        
+        def schedule_const_for_unloading_with_instrumentation(const_name)
+          boost_log_schedule_const_removal('SCHEDULE_REMOVAL', const_name, const_name)
+          schedule_const_for_unloading_without_instrumentation(const_name)
         end
 
       private
@@ -69,9 +74,9 @@ module RailsDevelopmentBoost
             end
           end
           
-          def unload_containing_file_with_instrumentation(const_name, file)
-            boost_log('UNLOAD_CONTAINING_FILE', "#{const_name} -> #{file.boost_inspect}")
-            unload_containing_file_without_instrumentation(const_name, file)
+          def schedule_containing_file_with_instrumentation(const_name, file)
+            boost_log('SCHEDULE_CONTAINING_FILE', "#{const_name} -> #{file.boost_inspect}")
+            schedule_containing_file_without_instrumentation(const_name, file)
           end
         end
       end
@@ -79,14 +84,14 @@ module RailsDevelopmentBoost
       module Files
         include Instrumenter
         
-        def unload_modified_file_with_instrumentation(file)
+        def schedule_modified_file_with_instrumentation(file)
           boost_log('CHANGED', "#{file.boost_inspect}")
-          unload_modified_file_without_instrumentation(file)
+          boost_log_nested { schedule_modified_file_without_instrumentation(file) }
         end
         
-        def unload_decorator_file_with_instrumentation(file)
-          boost_log('UNLOAD_DECORATOR_FILE', "#{file.boost_inspect}")
-          unload_decorator_file_without_instrumentation(file)
+        def schedule_decorator_file_with_instrumentation(file)
+          boost_log('SCHEDULE_DECORATOR_FILE', "#{file.boost_inspect}")
+          schedule_decorator_file_without_instrumentation(file)
         end
       end
       
@@ -123,15 +128,23 @@ module RailsDevelopmentBoost
         raw_boost_log("#{ "[#{action}] " if action}#{msg}")
       end
       
-      private
-      def unprotected_remove_constant(const_name)
-        boost_log('REMOVING', const_name)
+      def boost_log_schedule_const_removal(action, msg, const_name)
+        action = "#{action} | #{ActiveSupport::Dependencies.constants_to_remove.seen?(const_name) ? 'SKIP' : 'SCHEDULED'}"
+        boost_log(action, msg)
+      end
+      
+      def boost_log_nested
         @removal_nesting = (@removal_nesting || 0) + 1
-        super
+        yield
       ensure
         @removal_nesting -= 1
       end
       
+      private
+      def schedule_dependent_constants_for_removal(const_name, object)
+        boost_log_nested { super }
+      end
+      
       def error_loading_file(file_path, e)
         description = RailsDevelopmentBoost::LoadedFile.loaded?(file_path) ? RailsDevelopmentBoost::LoadedFile.for(file_path).boost_inspect : file_path
         boost_log('ERROR_WHILE_LOADING', "#{description}: #{e.inspect}")
@@ -139,32 +152,34 @@ module RailsDevelopmentBoost
       end
       
       def remove_explicit_dependency(const_name, depending_const)
-        boost_log('EXPLICIT_DEPENDENCY', "#{const_name} -> #{depending_const}")
+        boost_log_schedule_const_removal('EXPLICIT_DEPENDENCY', "#{const_name} -> #{depending_const}", depending_const)
         super
       end
       
       def remove_dependent_constant(original_module, dependent_module)
-        boost_log('DEPENDENT_MODULE', "#{original_module._mod_name} -> #{dependent_module._mod_name}")
+        const_name = dependent_module._mod_name
+        boost_log_schedule_const_removal('DEPENDENT_MODULE', "#{original_module._mod_name} -> #{const_name}", const_name)
         super
       end
       
       def remove_autoloaded_parent_module(initial_object, parent_object)
-        boost_log('REMOVE_PARENT', "#{initial_object._mod_name} -> #{parent_object._mod_name}")
+        const_name = parent_object._mod_name
+        boost_log_schedule_const_removal('REMOVE_PARENT', "#{initial_object._mod_name} -> #{const_name}", const_name)
         super
       end
       
       def remove_child_module_constant(parent_object, full_child_const_name)
-        boost_log('REMOVE_CHILD', "#{parent_object._mod_name} -> #{full_child_const_name}")
+        boost_log_schedule_const_removal('REMOVE_CHILD', "#{parent_object._mod_name} -> #{full_child_const_name}", full_child_const_name)
         super
       end
       
       def remove_nested_constant(parent_const, child_const)
-        boost_log('REMOVE_NESTED', "#{parent_const} :: #{child_const.sub(/\A#{parent_const}::/, '')}")
+        boost_log_schedule_const_removal('REMOVE_NESTED', "#{parent_const} :: #{child_const.sub(/\A#{parent_const}::/, '')}", child_const)
         super
       end
       
       def raw_boost_log(msg)
-        Rails.logger.info("[DEV-BOOST] #{"\t" * (@removal_nesting || 0)}#{msg}")
+        Rails.logger.info("[DEV-BOOST] #{"  " * (@removal_nesting || 0)}#{msg}")
       end
     end
   end

data/lib/rails_development_boost/descendants_tracker_patch.rb

@@ -3,8 +3,16 @@ require 'active_support/descendants_tracker'
 module RailsDevelopmentBoost
   module DescendantsTrackerPatch
     def self.apply!
+      # removing the .clear method across all Rails/Ruby versions
+      begin
+        ActiveSupport::DescendantsTracker.send(:remove_method, :clear)
+      rescue NameError
+      end
+      begin
+        ActiveSupport::DescendantsTracker.singleton_class.send(:remove_method, :clear)
+      rescue NameError
+      end
       ActiveSupport::DescendantsTracker.extend self
-      ActiveSupport::DescendantsTracker.singleton_class.remove_possible_method :clear
     end
     
     def delete(klass)

data/lib/rails_development_boost/loadable_patch.rb

@@ -5,11 +5,10 @@ module RailsDevelopmentBoost
     end
     
     def load(file, wrap = false)
-      expanded_path = File.expand_path(file)
+      real_path = DependenciesPatch::Util.load_path_to_real_path(file)
       # force the manual #load calls for autoloadable files to go through the AS::Dep stack
-      if ActiveSupport::Dependencies.in_autoload_path?(expanded_path)
-        expanded_path << '.rb' unless expanded_path =~ /\.(rb|rake)\Z/
-        ActiveSupport::Dependencies.load_file_from_explicit_load(expanded_path)
+      if ActiveSupport::Dependencies.in_autoload_path?(real_path)
+        ActiveSupport::Dependencies.load_file_from_explicit_load(real_path)
       else
         super
       end

data/lib/rails_development_boost/loaded_file.rb

@@ -1,40 +1,69 @@
+require 'set'
+
 module RailsDevelopmentBoost
   class LoadedFile
     class Files < Hash
       def initialize(*args)
+        @directories = {}
         super {|hash, file_path| hash[file_path] = LoadedFile.new(file_path)}
       end
       
-      def unload_modified!
-        each_file_unload_if_changed {|file| file.changed?}
+      def []=(file_path, loaded_file)
+        (@directories[loaded_file.dirname] ||= Set.new) << loaded_file
+        super
+      end
+      
+      def delete(file_path)
+        if loaded_file = super
+          dirname = loaded_file.dirname
+          if @directories[dirname].delete(loaded_file).empty?
+            @directories.delete(dirname)
+          end
+        end
+        loaded_file
       end
       
-      def each_file_unload_if_changed
+      def unload_modified!(filter_directories = nil)
         unloaded_something = false
-        values.each do |file|
-          if yield(file)
-            unload_modified_file(file)
+        find_files_in(filter_directories).each do |file|
+          if file.changed?
+            schedule_modified_file(file)
             unloaded_something = true
           end
         end
         if unloaded_something
           values.each do |file|
-            unload_decorator_file(file) if file.decorator_like?
+            schedule_decorator_file(file) if file.decorator_like?
           end
         end
+        ActiveSupport::Dependencies.process_consts_scheduled_for_removal
         unloaded_something
       end
       
-      def unload_modified_file(file)
-        file.unload!
+      def find_files_in(filter_directories = nil)
+        if filter_directories
+          arr = []
+          @directories.each_pair do |dirname, files|
+            arr.concat(files.to_a) if filter_directories.any? {|filter_directory| dirname.starts_with?(filter_directory)}
+          end
+          arr
+        else
+          values
+        end
       end
       
-      def unload_decorator_file(file)
-        file.unload!
+      def schedule_modified_file(file)
+        file.schedule_consts_for_unloading!
+      end
+      
+      def schedule_decorator_file(file)
+        file.schedule_consts_for_unloading!
       end
       
       def constants
-        values.map(&:constants).flatten
+        arr = []
+        each_value {|file| arr.concat(file.constants)}
+        arr
       end
       
       def stored?(file)
@@ -110,16 +139,20 @@ module RailsDevelopmentBoost
       @constants |= new_constants
     end
     
+    def dirname
+      File.dirname(@path)
+    end
+    
     # "decorator" files are popular with certain Rails frameworks (spree/refinerycms etc.) they don't define their own constants, instead
     # they are usually used for adding methods to other classes via Model.class_eval { def meth; end }
     def decorator_like?
       @constants.empty? && !INTERDEPENDENCIES[self]
     end
     
-    def unload!
+    def schedule_consts_for_unloading!
       guard_double_unloading do
-        INTERDEPENDENCIES.each_dependent_on(self) {|dependent_file| unload_dependent_file(dependent_file)}
-        @constants.dup.each {|const| ActiveSupport::Dependencies.remove_constant(const)}
+        INTERDEPENDENCIES.each_dependent_on(self) {|dependent_file| dependent_file_schedule_for_unloading!(dependent_file)}
+        @constants.dup.each {|const| schedule_const_for_unloading(const)}
         clean_up_if_necessary
       end
     end
@@ -166,8 +199,8 @@ module RailsDevelopmentBoost
       @path.eql?(other)
     end
     
-    def unload_dependent_file(dependent_file)
-      dependent_file.unload!
+    def dependent_file_schedule_for_unloading!(dependent_file)
+      dependent_file.schedule_consts_for_unloading!
     end
     
     def guard_double_unloading
@@ -206,6 +239,10 @@ module RailsDevelopmentBoost
       INTERDEPENDENCIES.each_dependent_on(self, &:stale!)
     end
     
+    def schedule_const_for_unloading(const_name)
+      ActiveSupport::Dependencies.schedule_const_for_unloading(const_name)
+    end
+    
     class << self
       def unload_modified!
         LOADED.unload_modified!
@@ -227,12 +264,12 @@ module RailsDevelopmentBoost
         CONSTANTS_TO_FILES[const_name]
       end
       
-      def unload_files_with_const!(const_name)
-        CONSTANTS_TO_FILES.each_file_with_const(const_name) {|file| unload_containing_file(const_name, file)}
+      def schedule_for_unloading_files_with_const!(const_name)
+        CONSTANTS_TO_FILES.each_file_with_const(const_name) {|file| schedule_containing_file(const_name, file)}
       end
       
-      def unload_containing_file(const_name, file)
-        file.unload!
+      def schedule_containing_file(const_name, file)
+        file.schedule_consts_for_unloading!
       end
       
       def const_unloaded(const_name)
@@ -250,4 +287,28 @@ module RailsDevelopmentBoost
       File.mtime(@path).to_i rescue nil
     end
   end
+  
+  class RoutesLoadedFile < LoadedFile
+    def decorator_like?
+      false
+    end
+    
+    def changed?
+      false
+    end
+    
+    def schedule_consts_for_unloading!
+      Reloader.routes_reloader.force_execute!
+    end
+    
+    def add_constants(new_constants)
+    end
+    
+    def clean_up_if_necessary
+    end
+    
+    def self.for(file_path)
+      LOADED.loaded?(file_path) ? LOADED[file_path] : LOADED[file_path] = new(file_path)
+    end
+  end
 end

data/lib/rails_development_boost/reloader.rb

@@ -1,10 +1,41 @@
 module RailsDevelopmentBoost
   module Reloader # replacement for the Rails' post fa1d9a file_update_checker
+    module RoutesReloaderPatch
+      def force_execute!
+        @force_execute = true
+      end
+      
+      def updated?
+        @force_execute = true if result = super
+        result
+      end
+      
+      def execute
+        if RailsDevelopmentBoost.reload_routes_on_any_change || @in_execute_if_updated || @force_execute || updated?
+          @force_execute = false
+          super
+        end
+      end
+      
+      def load(file, wrap = false)
+        ActiveSupport::Dependencies.loading_routes_file(file) { super }
+      end
+      
+      def execute_if_updated
+        old_in_execute_if_updated = @in_execute_if_updated
+        @in_execute_if_updated = true
+        super
+      ensure
+        @in_execute_if_updated = old_in_execute_if_updated
+      end
+    end
+    
     extend self
     
     def hook_in!
       Rails.application.reloaders.unshift(self)
       ActionDispatch::Reloader.to_prepare(:prepend => true) { RailsDevelopmentBoost::Reloader.execute_if_updated }
+      patch_routes_reloader! if Rails::VERSION::MAJOR >= 4
     end
     
     def execute
@@ -20,7 +51,19 @@ module RailsDevelopmentBoost
 
     alias_method :updated?, :execute
     
+    def routes_reloader
+      Rails.application.respond_to?(:routes_reloader) && Rails.application.routes_reloader
+    end
+    
     private
+    # Rails 4.0+ calls routes_reloader.execute instead of routes_reloader.execute_if_updated because an autoloaded Rails::Engine might be mounted via routes.rb, therefore if any constants
+    # are unloaded this triggers the reloading of routes.rb, we would like to avoid that.
+    def patch_routes_reloader!
+      if reloader = routes_reloader
+        reloader.extend(RoutesReloaderPatch)
+      end
+    end
+    
     def init
       Rails.application.reloaders.delete_if do |reloader|
         if rails_file_checker?(reloader)
@@ -43,7 +86,7 @@ module RailsDevelopmentBoost
       if (dir_glob = reloader.instance_variable_get(:@glob)).kind_of?(String)
         autoload_paths = ActiveSupport::Dependencies.autoload_paths
         dir_glob.sub(/\A\{/, '').sub(/\}\Z/, '').split(',').all? do |glob_path|
-          autoload_paths.any? {|autoload_path| glob_path.starts_with?(autoload_path)}
+          autoload_paths.any? {|autoload_path| glob_path.starts_with?(autoload_path.to_s)}
         end
       end
     end

metadata

@@ -1,50 +1,40 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rails-dev-boost
-version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+version: !ruby/object:Gem::Version
+  version: 0.3.0
 platform: ruby
-authors: 
+authors:
 - Roman Le Negrate
 - thedarkone
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-02 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rails
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
+date: 2014-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Make your Rails app 10 times faster in development mode
 email: roman.lenegrate@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.markdown
-files: 
+files:
 - lib/rails-dev-boost.rb
+- lib/rails_development_boost/async/reactor.rb
 - lib/rails_development_boost/async.rb
 - lib/rails_development_boost/dependencies_patch/instrumentation_patch.rb
 - lib/rails_development_boost/dependencies_patch.rb
@@ -92,41 +82,31 @@ files:
 - LICENSE
 - README.markdown
 - VERSION
-has_rdoc: true
 homepage: http://github.com/thedarkone/rails-dev-boost
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --charset=UTF-8
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 3
 summary: Speeds up Rails development mode
-test_files: 
+test_files:
 - test/constants/active_record/comment.rb
 - test/constants/active_record/message.rb
 - test/constants/active_record/other.rb