padrino-core 0.9.28 → 0.9.29

data/lib/padrino-core/cli/rake.rb

@@ -1,79 +1,24 @@
-require File.expand_path(File.dirname(__FILE__) + '/../tasks')
+require File.expand_path('../../tasks', __FILE__)
 require 'rake'
+require 'thor'
 require 'securerandom' unless defined?(SecureRandom)
-Rake.application.instance_variable_set(:@rakefile, __FILE__)
 
 module PadrinoTasks
-  def self.init
-    Padrino::Tasks.files.flatten.uniq.each { |ext| load(ext) rescue puts "<= Failed load #{ext}" } unless @_init
-    Rake.application.init
-    Rake.application.top_level
-    @_init = true
+  def self.init(init=false)
+    Padrino::Tasks.files.flatten.uniq.each { |rakefile| Rake.application.add_import(rakefile) rescue puts "<= Failed load #{ext}" }
+    if init
+      Rake.application.init
+      Rake.application.instance_variable_set(:@rakefile, __FILE__)
+      load(File.expand_path('../rake_tasks.rb', __FILE__))
+      Rake.application.load_imports
+      Rake.application.top_level
+    else
+      load(File.expand_path('../rake_tasks.rb', __FILE__))
+      Rake.application.load_imports
+    end
   end
 end
 
 def shell
   @_shell ||= Thor::Base.shell.new
-end
-
-# Load rake tasks from common rake task definition locations
-Dir["lib/tasks/**/*.rake"].
-  concat(Dir["tasks/**/*.rake"]).
-  concat(Dir["{test,spec}/*.rake"]).each  { |ext| load(ext) }
-
-# Loads the Padrino applications mounted within the project
-# setting up the required environment for Padrino
-task :environment do
-  Padrino.mounted_apps.each do |app|
-    app.app_obj.setup_application!
-  end
-end
-
-desc "Generate a secret key"
-task :secret do
-  shell.say SecureRandom.hex(32)
-end
-
-# lists all routes of a given app
-def list_app_routes(app, args)
-  app_routes = app.named_routes
-  app_routes.reject! { |r| r.identifier.to_s !~ /#{args.query}/ } if args.query.present?
-  app_routes.map! { |r| [r.verb, r.name, r.path] }
-  return if app_routes.empty?
-  shell.say "\nApplication: #{app.app_class}", :yellow
-  app_routes.unshift(["REQUEST", "URL", "PATH"])
-  max_col_1 = app_routes.max { |a, b| a[0].size <=> b[0].size }[0].size
-  max_col_2 = app_routes.max { |a, b| a[1].size <=> b[1].size }[1].size
-  app_routes.each_with_index do |row, i|
-    message = [row[1].ljust(max_col_2+2), row[0].center(max_col_1+2), row[2]]
-    shell.say("    " + message.join(" "), i==0 ? :bold : nil)
-  end
-end
-
-desc "Displays a listing of the named routes within a project, optionally only those matched by [query]"
-task :routes, :query, :needs => :environment do |t, args|
-  Padrino.mounted_apps.each do |app|
-    list_app_routes(app, args)
-  end
-end
-
-desc "Displays a listing of the named routes a given app [app]"
-namespace :routes do
-  task :app, :app, :needs => :environment do |t, args|
-    app = Padrino.mounted_apps.find { |app| app.app_class == args.app }
-    list_app_routes(app, args) if app
-  end
-end
-
-desc "Generate the Rakefile"
-task :gen do
-  File.open(Padrino.root("Rakefile"), "w") do |file|
-    file.puts <<-RUBY.gsub(/^ {6}/, '')
-      require File.dirname(__FILE__) + '/config/boot.rb'
-      require 'thor'
-      require 'padrino-core/cli/rake'
-
-      PadrinoTasks.init
-    RUBY
-  end
 end

data/lib/padrino-core/cli/rake_tasks.rb

@@ -0,0 +1,59 @@
+# Load rake tasks from common rake task definition locations
+Dir["lib/tasks/**/*.rake"].
+  concat(Dir["tasks/**/*.rake"]).
+  concat(Dir["{test,spec}/*.rake"]).each  { |rake| load(rake) }
+
+# Loads the Padrino applications mounted within the project
+# setting up the required environment for Padrino
+task :environment do
+  Padrino.mounted_apps.each do |app|
+    app.app_obj.setup_application!
+  end
+end
+
+desc "Generate a secret key"
+task :secret do
+  shell.say SecureRandom.hex(32)
+end
+
+# lists all routes of a given app
+def list_app_routes(app, args)
+  app_routes = app.named_routes
+  app_routes.reject! { |r| r.identifier.to_s !~ /#{args.query}/ } if args.query.present?
+  app_routes.map! { |r| [r.verb, r.name, r.path] }
+  return if app_routes.empty?
+  shell.say "\nApplication: #{app.app_class}", :yellow
+  app_routes.unshift(["REQUEST", "URL", "PATH"])
+  max_col_1 = app_routes.max { |a, b| a[0].size <=> b[0].size }[0].size
+  max_col_2 = app_routes.max { |a, b| a[1].size <=> b[1].size }[1].size
+  app_routes.each_with_index do |row, i|
+    message = [row[1].ljust(max_col_2+2), row[0].center(max_col_1+2), row[2]]
+    shell.say("    " + message.join(" "), i==0 ? :bold : nil)
+  end
+end
+
+desc "Displays a listing of the named routes within a project, optionally only those matched by [query]"
+task :routes, [:query] => :environment do |t, args|
+  Padrino.mounted_apps.each do |app|
+    list_app_routes(app, args)
+  end
+end
+
+desc "Displays a listing of the named routes a given app [app]"
+namespace :routes do
+  task :app, [:app] => :environment do |t, args|
+    app = Padrino.mounted_apps.find { |app| app.app_class == args.app }
+    list_app_routes(app, args) if app
+  end
+end
+
+desc "Generate the Rakefile"
+task :gen do
+  File.open(Padrino.root("Rakefile"), "w") do |file|
+    file.puts <<-RUBY.gsub(/^ {6}/, '')
+      require File.expand_path('../config/boot.rb', __FILE__)
+      require 'padrino-core/cli/rake'
+      PadrinoTasks.init
+    RUBY
+  end
+end

data/lib/padrino-core/loader.rb

@@ -13,7 +13,7 @@ module Padrino
     #
     def before_load(&block)
       @_before_load ||= []
-      @_before_load << Proc.new(&block) if block_given?
+      @_before_load << block if block_given?
       @_before_load
     end
 
@@ -29,33 +29,58 @@ module Padrino
     #
     def after_load(&block)
       @_after_load ||= []
-      @_after_load << Proc.new(&block) if block_given?
+      @_after_load << block if block_given?
       @_after_load
     end
 
+    ##
+    # Returns the used $LOAD_PATHS from padrino
+    #
+    def load_paths
+      @_load_paths_was = %w(lib models shared).map { |path| Padrino.root(path) }
+      @_load_paths ||= @_load_paths_was
+    end
+
     ##
     # Requires necessary dependencies as well as application files from root lib and models
     #
     def load!
       return false if loaded?
       @_called_from = first_caller
-      set_encoding
-      set_load_paths(*load_paths) # We set the padrino load paths
+      Padrino.set_encoding
+      Padrino.set_load_paths(*load_paths) # We set the padrino load paths
       Padrino.logger # Initialize our logger
-      before_load.each { |bl| bl.call } # Run before hooks
-      dependency_paths.each { |path| require_dependencies(path) }
-      Reloader::Stat.run! # We need to fill our Stat::CACHE
-      after_load.each { |al| al.call } # Run after hooks
+      Padrino.require_dependencies("#{root}/config/database.rb", :nodeps => true) # Be sure to don't remove constants from dbs.
+      Padrino::Reloader.lock! # Now we can remove constant from here to down
+      Padrino.before_load.each(&:call) # Run before hooks
+      Padrino.dependency_paths.each { |path| Padrino.require_dependencies(path) }
+      Padrino.after_load.each(&:call) # Run after hooks
+      Padrino::Reloader.run!
       Thread.current[:padrino_loaded] = true
     end
 
+    ##
+    # Clear the padrino env
+    #
+    def clear!
+      Padrino.clear_middleware!
+      Padrino.mounted_apps.clear
+      @_load_paths = nil
+      @_dependency_paths = nil
+      @_global_configuration = nil
+      Padrino.before_load.clear
+      Padrino.after_load.clear
+      Padrino::Reloader.clear!
+      Thread.current[:padrino_loaded] = nil
+    end
+
     ##
     # Method for reloading required applications and their files
     #
     def reload!
-      before_load.each { |bl| bl.call } # Run before hooks
-      Reloader::Stat.reload! # detects the modified files
-      after_load.each { |al| al.call } # Run after hooks
+      Padrino.before_load.each(&:call) # Run before hooks
+      Padrino::Reloader.reload! # detects the modified files
+      Padrino.after_load.each(&:call) # Run after hooks
     end
 
     ##
@@ -95,8 +120,10 @@ module Padrino
     #   require_dependencies("#{Padrino.root}/lib/**/*.rb")
     #
     def require_dependencies(*paths)
+      options = paths.extract_options!
+
       # Extract all files to load
-      files = paths.map { |path| Dir[path] }.flatten.uniq.sort
+      files = paths.flatten.map { |path| Dir[path] }.flatten.uniq.sort
 
       while files.present?
         # List of errors and failed files
@@ -110,7 +137,7 @@ module Padrino
         # iteration, this prevent problems with rubinus
         files.dup.each do |file|
           begin
-            Reloader::Stat.safe_load(file)
+            Padrino::Reloader.safe_load(file, options.dup)
             files.delete(file)
           rescue LoadError => e
             errors << e
@@ -131,43 +158,25 @@ module Padrino
 
     ##
     # Returns default list of path globs to load as dependencies
-    #
-    def dependency_paths
-      # Load db adapter, libs, root models, app configuration
-      @dependency_paths ||= [
-        "#{root}/config/database.rb", "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
-        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb", @custom_dependencies,
-        "#{root}/config/apps.rb"
-      ].flatten.compact
-    end
-
-    ##
     # Appends custom dependency patterns to the be loaded for Padrino
     #
     # ==== Examples
-    #    Padrino.custom_dependencies("#{Padrino.root}/foo/bar/*.rb")
+    #    Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
     #
-    def custom_dependencies(*globs)
-      @custom_dependencies ||= []
-      @custom_dependencies.concat(globs)
-    end
-
-    ##
-    # Attempts to load all dependency libs that we need.
-    # If you use this method we can perform correctly a Padrino.reload!
-    #
-    def load_dependencies(*paths)
-      paths.each do |path|
-        FileSet.glob(path) { |file| load(file) }
-      end
+    def dependency_paths
+      @_dependency_paths_was = [
+        "#{root}/config/database.rb", "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
+        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb", "#{root}/config/apps.rb"
+      ]
+      @_dependency_paths ||= @_dependency_paths_was
     end
 
     ##
     # Concat to $LOAD_PATH the given paths
     #
     def set_load_paths(*paths)
-      $:.concat(paths)
-      $:.uniq!
+      $:.concat(paths); load_paths.concat(paths)
+      $:.uniq!; load_paths.uniq!
     end
   end # self
-end # Padrino
+end # Padrino

data/lib/padrino-core/logger.rb

@@ -15,6 +15,13 @@ module Padrino
     Thread.current[:padrino_logger] ||= Padrino::Logger.setup!
   end
 
+  ##
+  # Set the padrino logger
+  #
+  def self.logger=(value)
+    Thread.current[:padrino_logger] = value
+  end
+
   ##
   # Extensions to the built in Ruby logger.
   #
@@ -42,11 +49,12 @@ module Padrino
     # :debug:: low-level information for developers
     #
     Levels = {
-      :fatal => 7,
-      :error => 6,
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
+      :fatal =>  7,
+      :error =>  6,
+      :warn  =>  4,
+      :info  =>  3,
+      :debug =>  0,
+      :devel => -1,
     } unless const_defined?(:Levels)
 
     @@mutex = {}
@@ -113,7 +121,8 @@ module Padrino
       :error => [RED],
       :warn  => [YELLOW],
       :info  => [GREEN],
-      :debug => [CYAN]
+      :debug => [CYAN],
+      :devel => [MAGENTA]
     } unless defined?(ColoredLevels)
 
     ##
@@ -285,6 +294,7 @@ module Padrino
 
       def call(env)
         env['rack.logger'] = Padrino.logger
+        env['rack.errors'] = Padrino.logger.log
         began_at = Time.now
         status, header, body = @app.call(env)
         log(env, status, header, began_at)
@@ -330,4 +340,4 @@ module Kernel #:nodoc:
   def logger
     Padrino.logger
   end
-end # Kernel
+end # Kernel

data/lib/padrino-core/mounter.rb

@@ -22,6 +22,7 @@ module Padrino
       ensure_app_file! || ensure_app_object!
       @app_root  = options[:app_root]  || File.dirname(@app_file)
       @uri_root  = "/"
+      Padrino::Reloader.exclude_constants << @app_class
     end
 
     ##

data/lib/padrino-core/reloader.rb

@@ -5,57 +5,6 @@ module Padrino
   # High performance source code reloader middleware
   #
   module Reloader
-    ##
-    # This class acts as a Rack middleware to be added to the application stack. This middleware performs a
-    # check and reload for source files at the start of each request, but also respects a specified cool down time
-    # during which no further action will be taken.
-    #
-    class Rack
-      def initialize(app, cooldown = 1)
-        @app = app
-        @cooldown = cooldown
-        @last = (Time.now - cooldown)
-      end
-
-      def call(env)
-        if @cooldown and Time.now > @last + @cooldown
-          if Thread.list.size > 1
-            Thread.exclusive { Padrino.reload! }
-          else
-            Padrino.reload!
-          end
-
-          @last = Time.now
-        end
-
-        @app.call(env)
-      end
-    end
-
-    ##
-    # Specified folders can be excluded from the code reload detection process.
-    # Default excluded directories at Padrino.root are: test, spec, features, tmp, config, db and public
-    #
-    def self.exclude
-      @_exclude ||= %w(test spec tmp features config public db).map { |path| Padrino.root(path) }
-    end
-
-    ##
-    # Specified constants can be excluded from the code unloading process.
-    # Default excluded constants are: Padrino, Sinatra
-    #
-    def self.exclude_constants
-      @_exclude_constants ||= %w(Padrino::Application Sinatra::Application Sinatra::Base)
-    end
-
-    ##
-    # Specified constants can be configured to be reloaded on every request.
-    # Default included constants are: [none]
-    #
-    def self.include_constants
-      @_include_constants ||= []
-    end
-
     ##
     # This reloader is suited for use in a many environments because each file
     # will only be checked once and only one system call to stat(2) is made.
@@ -63,195 +12,206 @@ module Padrino
     # Please note that this will not reload files in the background, and does so
     # only when explicitly invoked.
     #
-    module Stat
-      class << self
-        CACHE                = {}
-        MTIMES               = {}
-        FILES_LOADED         = {}
-        LOADED_CLASSES       = {}
+    MTIMES          = {}
+    FILES_LOADED    = {}
+    LOADED_CLASSES  = {}
+
+    class << self
+      ##
+      # Specified folders can be excluded from the code reload detection process.
+      # Default excluded directories at Padrino.root are: test, spec, features, tmp, config, db and public
+      #
+      def exclude
+        @_exclude ||= %w(test spec tmp features config public db).map { |path| Padrino.root(path) }
+      end
 
-        ##
-        # Reload all files with changes detected.
-        #
-        def reload!
-          # Detect changed files
-          rotation do |file, mtime|
-            # Retrive the last modified time
-            new_file = MTIMES[file].nil?
-            previous_mtime = MTIMES[file] ||= mtime
-            logger.debug "Detected a new file #{file}" if new_file
-            # We skip to next file if it is not new and not modified
-            next unless new_file || mtime > previous_mtime
-            # If the file is related to their app (i.e. a controller/mailer/helper)
-            Padrino.mounted_apps.find_all { |a| file =~ /^#{File.dirname(a.app_file)}/ }.each do |app|
-              # We need to reload their own app
-              app.app_obj.reload!
-              # App reloading will also perform safe_load of itself so we can go next
-              if File.identical?(app.app_file, file)
-                MTIMES[file] = mtime # This prevent a loop
-                next
-              end
+      ##
+      # Specified constants can be excluded from the code unloading process.
+      #
+      def exclude_constants
+        @_exclude_constants ||= []
+      end
+
+      ##
+      # Specified constants can be configured to be reloaded on every request.
+      # Default included constants are: [none]
+      #
+      def include_constants
+        @_include_constants ||= []
+      end
+      ##
+      # Reload all files with changes detected.
+      #
+      def reload!
+        # Detect changed files
+        rotation do |file, mtime|
+          # Retrive the last modified time
+          new_file = MTIMES[file].nil?
+          previous_mtime = MTIMES[file] ||= mtime
+          logger.devel "Detected a new file #{file}" if new_file
+          # We skip to next file if it is not new and not modified
+          next unless new_file || mtime > previous_mtime
+          # Now we can reload our file
+          apps = get_apps(file)
+          if apps.present?
+            apps.each { |app| app.app_obj.reload! }
+          else
+            safe_load(file, :force => new_file)
+            # Reload also apps
+            Padrino.mounted_apps.each do |app|
+              app.app_obj.reload! if app.app_obj.dependencies.include?(file)
             end
-            # Now we can reload our file
-            safe_load(file, mtime)
           end
         end
+      end
 
-        ##
-        # Returns true if any file changes are detected and populates the MTIMES cache
-        #
-        def changed?
-          changed = false
-          rotation do |file, mtime|
-            new_file = MTIMES[file].nil?
-            previous_mtime = MTIMES[file] ||= mtime
-            changed = true if new_file || mtime > previous_mtime
-          end
-          changed
+      ##
+      # Remove files and classes loaded with stat
+      #
+      def clear!
+        MTIMES.clear
+        LOADED_CLASSES.each do |file, klasses|
+          klasses.each { |klass| remove_constant(klass) }
+          LOADED_CLASSES.delete(file)
         end
-        alias :run! :changed?
-
-        ##
-        # A safe Kernel::load which issues the necessary hooks depending on results
-        #
-        def safe_load(file, mtime=nil)
-          reload = mtime && mtime > MTIMES[file]
-
-          logger.debug "Reloading #{file}" if reload
+        FILES_LOADED.each do |file, dependencies|
+          dependencies.each { |dependency| $LOADED_FEATURES.delete(dependency) }
+          $LOADED_FEATURES.delete(file)
+        end
+      end
 
-          # Removes all classes declared in the specified file
-          if klasses = LOADED_CLASSES.delete(file)
-            klasses.each { |klass| remove_constant(klass) }
-          end
+      ##
+      # Returns true if any file changes are detected and populates the MTIMES cache
+      #
+      def changed?
+        changed = false
+        rotation do |file, mtime|
+          new_file = MTIMES[file].nil?
+          previous_mtime = MTIMES[file] ||= mtime
+          changed = true if new_file || mtime > previous_mtime
+        end
+        changed
+      end
+      alias :run! :changed?
+
+      ##
+      # We lock dependencies sets to prevent reloading of protected constants
+      #
+      def lock!
+        klasses = ObjectSpace.classes.map { |klass| klass.to_s.split("::")[0] }.uniq
+        klasses = klasses | Padrino.mounted_apps.map { |app| app.app_class }
+        Padrino::Reloader.exclude_constants.concat(klasses)
+      end
 
-          # Keeps track of which constants were loaded and the files
-          # that have been added so that the constants can be removed
-          # and the files can be removed from $LOADED_FEAUTRES
-          if FILES_LOADED[file]
-            FILES_LOADED[file].each do |fl|
-              next if fl == file
-              $LOADED_FEATURES.delete(fl)
-            end
-          end
+      ##
+      # A safe Kernel::require which issues the necessary hooks depending on results
+      #
+      def safe_load(file, options={})
+        force, file = options[:force], figure_path(file)
 
-          # Now reload the file ignoring any syntax errors
-          $LOADED_FEATURES.delete(file)
+        reload = MTIMES[file] && File.mtime(file) > MTIMES[file]
+        return if !force && !reload && MTIMES[file]
 
-          # Duplicate objects and loaded features in the file
-          klasses = ObjectSpace.classes.dup
-          files_loaded = $LOADED_FEATURES.dup
+        # Removes all classes declared in the specified file
+        if klasses = LOADED_CLASSES.delete(file)
+          klasses.each { |klass| remove_constant(klass) }
+        end
 
-          # Start to re-require old dependencies
-          #
-          # Why we need to reload the dependencies i.e. of a model?
-          #
-          # In some circumstances (i.e. with MongoMapper) reloading a model require:
-          #
-          # 1) Clean objectspace
-          # 2) Reload model dependencies
-          #
-          # We need to clean objectspace because for example we don't need to apply two times validations keys etc...
-          #
-          # We need to reload MongoMapper dependencies for re-initialize them.
-          #
-          # In other cases i.e. in a controller (specially with dependencies that uses autoload) reload stuff like sass
-          # is not really necessary... but how to distinguish when it is (necessary) since it is not?
-          #
-          if FILES_LOADED[file]
-            FILES_LOADED[file].each do |fl|
-              next if fl == file
-              # Swich off for a while warnings expecially "already initialized constant" stuff
-              begin
-                verbosity = $-v
-                $-v = nil
-                require(fl)
-              ensure
-                $-v = verbosity
-              end
-            end
-          end
+        # Duplicate objects and loaded features in the file
+        klasses = ObjectSpace.classes.dup
 
-          # And finally reload the specified file
-          begin
-            require(file)
-          rescue SyntaxError => ex
-            logger.error "Cannot require #{file} because of syntax error: #{ex.message}"
-          ensure
-            MTIMES[file] = mtime if mtime
-          end
+        # And finally reload the specified file
+        begin
+          logger.devel "Loading #{file}#{' with force' if force}" if !reload
+          logger.debug "Reloading #{file}" if reload
+          $LOADED_FEATURES.delete(file)
+          require(file)
+          MTIMES[file] = File.mtime(file)
+        rescue SyntaxError => ex
+          logger.error "Cannot require #{file} because of syntax error: #{ex.message}"
+        end
 
-          # Store the file details after successful loading
-          LOADED_CLASSES[file] = ObjectSpace.classes - klasses
-          FILES_LOADED[file]   = $LOADED_FEATURES - files_loaded
+        # Store the file details after successful loading
+        LOADED_CLASSES[file] ||= (ObjectSpace.classes - klasses).uniq
+      end
 
-          nil
+      ##
+      # Returns true if the file is defined in our padrino root
+      #
+      def figure_path(file)
+        return file if Pathname.new(file).absolute?
+        $:.each do |path|
+          found = File.join(path, file)
+          return File.expand_path(found) if File.exist?(found)
         end
+        file
+      end
 
-        ##
-        # Removes the specified class and constant.
-        #
-        def remove_constant(const)
-          return if Padrino::Reloader.exclude_constants.any? { |base| (const.to_s =~ /^#{base}/ || const.superclass.to_s =~ /^#{base}/) } &&
-                   !Padrino::Reloader.include_constants.any? { |base| (const.to_s =~ /^#{base}/ || const.superclass.to_s =~ /^#{base}/) }
-
-          parts = const.to_s.split("::")
-          base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::"))
+      ##
+      # Removes the specified class and constant.
+      #
+      def remove_constant(const)
+        return if Padrino::Reloader.exclude_constants.any? { |base| (const.to_s =~ %r{^#{base}}) } &&
+                 !Padrino::Reloader.include_constants.any? { |base| (const.to_s =~ %r{^#{base}}) }
+        begin
+          parts  = const.to_s.split("::")
+          base   = parts.size == 1 ? Object : parts[0..-2].join("::").constantize
           object = parts[-1].to_s
-          begin
-            base.send(:remove_const, object)
-          rescue NameError
-          end
+          logger.devel "Remove constant: #{const}"
+          base.send(:remove_const, object)
+        rescue NameError; end
+      end
 
-          nil
+      private
+        ##
+        # Return the mounted_app providing the app location
+        #
+        def get_apps(file)
+          file = figure_path(file)
+          Padrino.mounted_apps.find_all { |app| File.identical?(file, app.app_file) }
         end
 
         ##
-        # Searches Ruby files in your +Padrino.root+ and monitors them for any changes.
+        # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
+        # and monitors them for any changes.
         #
         def rotation
-          paths  = Dir[Padrino.root("*")].unshift(Padrino.root).
-                                          reject { |path| Padrino::Reloader.exclude.include?(path) || !File.directory?(path) }
-          files  = paths.map { |path| Dir["#{path}/**/*.rb"] }.flatten.uniq
-
-          files.map { |file|
-            next if Padrino::Reloader.exclude.any? { |base| file =~ /^#{Regexp.escape(base)}/ }
-
-            found, stat = figure_path(file, paths)
-            next unless found && stat && mtime = stat.mtime
-
-            CACHE[file] = found
-
-            yield(found, mtime)
+          files  = Padrino.load_paths.map { |path| Dir["#{path}/**/*.rb"] }.flatten
+          files  = files | Padrino.mounted_apps.map { |app| app.app_file }
+          files  = files | Padrino.mounted_apps.map { |app| app.app_obj.dependencies  }.flatten
+          files.uniq.map { |file|
+            file = File.expand_path(file)
+            next if Padrino::Reloader.exclude.any? { |base| file =~ %r{^#{base}} } || !File.exist?(file)
+            yield(file, File.mtime(file))
           }.compact
         end
+    end # self
 
-        ##
-        # Takes a relative or absolute +file+ name and a couple possible +paths+ that
-        # the +file+ might reside in. Returns the full path and File::Stat for that path.
-        #
-        def figure_path(file, paths)
-          found = CACHE[file]
-          found = file if !found and Pathname.new(file).absolute?
-          found, stat = safe_stat(found)
-          return found, stat if found
+    ##
+    # This class acts as a Rack middleware to be added to the application stack. This middleware performs a
+    # check and reload for source files at the start of each request, but also respects a specified cool down time
+    # during which no further action will be taken.
+    #
+    class Rack
+      def initialize(app, cooldown = 1)
+        @app = app
+        @cooldown = cooldown
+        @last = (Time.now - cooldown)
+      end
 
-          paths.find do |possible_path|
-            path = ::File.join(possible_path, file)
-            found, stat = safe_stat(path)
-            return ::File.expand_path(found), stat if found
+      def call(env)
+        if @cooldown and Time.now > @last + @cooldown
+          if Thread.list.size > 1
+            Thread.exclusive { Padrino.reload! }
+          else
+            Padrino.reload!
           end
 
-          return false, false
+          @last = Time.now
         end
 
-        def safe_stat(file)
-          return unless file
-          stat = ::File.stat(file)
-          return file, stat if stat.file?
-        rescue Errno::ENOENT, Errno::ENOTDIR
-          CACHE.delete(file) and false
-        end
-      end # self
-    end # Stat
+        @app.call(env)
+      end
+    end
   end # Reloader
 end # Padrino