padrino-core 0.11.4 → 0.12.0.rc1

data/lib/padrino-core/loader.rb

@@ -1,5 +1,5 @@
 module Padrino
-  class << self
+  module Loader
     ##
     # Hooks to be called before a load/reload.
     #
@@ -40,17 +40,6 @@ module Padrino
       @_after_load
     end
 
-    ##
-    # The used +$LOAD_PATHS+ from Padrino.
-    #
-    # @return [Array<String>]
-    #   The load paths used by 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.
@@ -60,21 +49,18 @@ module Padrino
     #
     def load!
       return false if loaded?
-      t = Time.now
-
+      began_at = Time.now
       @_called_from = first_caller
-      Padrino.set_encoding
-      Padrino.set_load_paths(*load_paths)
-      Padrino::Logger.setup! # Initialize our logger
-      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!
+      set_encoding
+      set_load_paths(*load_paths)
+      Logger.setup!
+      require_dependencies("#{root}/config/database.rb")
+      Reloader.lock!
+      before_load.each(&:call)
+      require_dependencies(*dependency_paths)
+      after_load.each(&:call)
+      logger.devel "Loaded Padrino in #{Time.now - began_at} seconds"
       Thread.current[:padrino_loaded] = true
-
-      Padrino.logger.devel "Loaded Padrino in #{Time.now - t} seconds"
     end
 
     ##
@@ -83,14 +69,14 @@ module Padrino
     # @return [NilClass]
     #
     def clear!
-      Padrino.clear_middleware!
-      Padrino.mounted_apps.clear
+      clear_middleware!
+      mounted_apps.clear
       @_load_paths = nil
       @_dependency_paths = nil
       @_global_configuration = nil
-      Padrino.before_load.clear
-      Padrino.after_load.clear
-      Padrino::Reloader.clear!
+      before_load.clear
+      after_load.clear
+      Reloader.clear!
       Thread.current[:padrino_loaded] = nil
     end
 
@@ -98,10 +84,10 @@ module Padrino
     # Method for reloading required applications and their files.
     #
     def reload!
-      return unless Padrino::Reloader.changed?
-      Padrino.before_load.each(&:call) # Run before hooks
-      Padrino::Reloader.reload! # detects the modified files
-      Padrino.after_load.each(&:call) # Run after hooks
+      return unless Reloader.changed?
+      before_load.each(&:call)
+      Reloader.reload!
+      after_load.each(&:call)
     end
 
     ##
@@ -147,38 +133,55 @@ module Padrino
     #   require_dependencies("#{Padrino.root}/lib/**/*.rb")
     #
     def require_dependencies(*paths)
-      options = paths.extract_options!
-
-      # Extract all files to load
-      files = paths.flatten.map { |path| Dir[path] }.flatten.uniq.sort
+      options = paths.extract_options!.merge( :cyclic => true )
+      files = paths.flatten.map{|path| Dir[path].sort_by{|v| v.count('/') }}.flatten.uniq
 
       while files.present?
-        errors, failed = [], []
+        error, fatal, loaded = nil, nil, nil
 
-        size_at_start = files.size
-
-        # Now we try to require our dependencies, we dup files
-        # so we don't perform delete on the original array during
-        # iteration, this prevent problems with Rubinus
         files.dup.each do |file|
           begin
-            Padrino::Reloader.safe_load(file, options.dup)
+            Reloader.safe_load(file, options)
             files.delete(file)
+            loaded = true
           rescue NameError, LoadError => e
-            Padrino.logger.devel "Problem while loading #{file}: #{e}"
-            errors << e
-            failed << file
+            logger.devel "Cyclic dependency reload for #{e.class}: #{e.message}"
+            error = e
           rescue Exception => e
-            raise e
+            fatal = e
+            break
           end
         end
 
-        # Stop processing if nothing loads or if everything has loaded
-        raise errors.last if files.size == size_at_start && files.present?
-        break if files.empty?
+        if fatal || !loaded
+          e = fatal || error
+          logger.error "#{e.class}: #{e.message}; #{e.backtrace.first}"
+          raise e
+        end
       end
     end
 
+    ##
+    # Concat to +$LOAD_PATH+ the given paths.
+    #
+    # @param [Array<String>] paths
+    #   The paths to concat.
+    #
+    def set_load_paths(*paths)
+      load_paths.concat(paths).uniq!
+      $LOAD_PATH.concat(paths).uniq!
+    end
+
+    ##
+    # The used +$LOAD_PATHS+ from Padrino.
+    #
+    # @return [Array<String>]
+    #   The load paths used by Padrino.
+    #
+    def load_paths
+      @_load_paths ||= load_paths_was.dup
+    end
+
     ##
     # Returns default list of path globs to load as dependencies.
     # Appends custom dependency patterns to the be loaded for Padrino.
@@ -190,35 +193,32 @@ module Padrino
     #   Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
     #
     def dependency_paths
-      @_dependency_paths ||= (dependency_paths_was + Array(module_paths))
-    end
-
-    ##
-    # Concat to +$LOAD_PATH+ the given paths.
-    #
-    # @param [Array<String>] paths
-    #   The paths to concat.
-    #
-    def set_load_paths(*paths)
-      $:.concat(paths); load_paths.concat(paths)
-      $:.uniq!; load_paths.uniq!
+      @_dependency_paths ||= dependency_paths_was + module_paths
     end
 
     private
 
     def module_paths
-      Padrino.modules.map(&:dependency_paths).flatten!
+      modules.map(&:dependency_paths).flatten
+    end
+
+    def load_paths_was
+      @_load_paths_was ||= [
+        "#{root}/lib",
+        "#{root}/models",
+        "#{root}/shared",
+      ].freeze
     end
 
     def dependency_paths_was
-      [
+      @_dependency_paths_was ||= [
         "#{root}/config/database.rb",
         "#{root}/lib/**/*.rb",
-        "#{root}/shared/lib/**/*.rb",
         "#{root}/models/**/*.rb",
+        "#{root}/shared/lib/**/*.rb",
         "#{root}/shared/models/**/*.rb",
         "#{root}/config/apps.rb"
-      ]
+      ].freeze
     end
   end
 end

data/lib/padrino-core/logger.rb

@@ -52,10 +52,10 @@ module Padrino
     # :devel:: Development-related information that is unnecessary in debug mode
     #
     Levels = {
-      :fatal =>  7,
-      :error =>  6,
-      :warn  =>  4,
-      :info  =>  3,
+      :fatal =>  4,
+      :error =>  3,
+      :warn  =>  2,
+      :info  =>  1,
       :debug =>  0,
       :devel => -1,
     } unless defined?(Levels)
@@ -194,13 +194,13 @@ module Padrino
       #
       def colorize(string, *colors)
         colors.each do |c|
-          string = string.send(c)
+          string = string.colorize(c)
         end
         string
       end
 
       def stylized_level(level)
-        style = ColoredLevels[level].map { |c| "\e[%dm" % String.colors[c] } * ''
+        style = ColoredLevels[level].map { |c| "\e[%dm" % String::Colorizer.colors[c] } * ''
         [style, super, "\e[0m"] * ''
       end
     end

data/lib/padrino-core/mounter.rb

@@ -8,10 +8,11 @@ module Padrino
   #   Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
   #
   class Mounter
+    DEFAULT_CASCADE = [404, 405]
     class MounterException < RuntimeError
     end
 
-    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host
+    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host, :cascade
 
     ##
     # @param [String, Padrino::Application] name
@@ -31,8 +32,9 @@ module Padrino
       @app_file  = options[:app_file]  || locate_app_file
       @app_obj   = options[:app_obj]   || app_constant || locate_app_object
       ensure_app_file! || ensure_app_object!
-      @app_root  = options[:app_root]  || File.dirname(@app_file)
+      @app_root  = options[:app_root]  || (@app_obj.respond_to?(:root) && @app_obj.root || File.dirname(@app_file))
       @uri_root  = "/"
+      @cascade   = options[:cascade] ? true == options[:cascade] ? DEFAULT_CASCADE.dup : Array(options[:cascade]) : []
       Padrino::Reloader.exclude_constants << @app_class
     end
 
@@ -82,11 +84,12 @@ module Padrino
     def map_onto(router)
       app_data, app_obj = self, @app_obj
       app_obj.set :uri_root,       app_data.uri_root
-      app_obj.set :app_name,       app_data.name
+      app_obj.set :app_name,       app_data.app_obj.app_name.to_s
       app_obj.set :app_file,       app_data.app_file unless ::File.exist?(app_obj.app_file)
       app_obj.set :root,           app_data.app_root unless app_data.app_root.blank?
       app_obj.set :public_folder,  Padrino.root('public', app_data.uri_root) unless File.exists?(app_obj.public_folder)
       app_obj.set :static,         File.exist?(app_obj.public_folder) if app_obj.nil?
+      app_obj.set :cascade,        app_data.cascade
       app_obj.setup_application! # Initializes the app here with above settings.
       router.map(:to => app_obj, :path => app_data.uri_root, :host => app_data.app_host)
     end
@@ -106,7 +109,9 @@ module Padrino
     #
     def named_routes
       app_obj.routes.map { |route|
-        name_array     = "(#{route.name.to_s.split("_").map { |piece| %Q[:#{piece}] }.join(", ")})"
+        route_name = route.name.to_s
+        route_name.sub!(/^#{route.controller} /, "") if route.controller
+        name_array = "(#{route.controller ? %Q[:#{route.controller}] + ", " : ""}:#{route_name})"
         request_method = route.request_methods.first
         next if route.name.blank? || request_method == 'HEAD'
         original_path = route.original_path.is_a?(Regexp) ? route.original_path.inspect : route.original_path

data/lib/padrino-core/reloader/rack.rb

@@ -0,0 +1,26 @@
+module Padrino
+  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
+
+      # Invoked in order to perform the reload as part of the request stack.
+      def call(env)
+        if @cooldown && Time.now > @last + @cooldown
+          Thread.list.size > 1 ? Thread.exclusive { Padrino.reload! } : Padrino.reload!
+          @last = Time.now
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/padrino-core/reloader/storage.rb

@@ -0,0 +1,55 @@
+module Padrino
+  module Reloader
+    module Storage
+      extend self
+
+      def clear!
+        files.each_key do |file|
+          remove(file)
+          $LOADED_FEATURES.delete(file)
+        end
+        @files = {}
+      end
+
+      def remove(name)
+        file = files[name] || return
+        file[:constants].each{ |constant| Reloader.remove_constant(constant) }
+        file[:features].each{ |feature| $LOADED_FEATURES.delete(feature) }
+        files.delete(name)
+      end
+
+      def prepare(name)
+        file = remove(name)
+        @old_entries ||= {}
+        @old_entries[name] = {
+          :constants => ObjectSpace.classes,
+          :features  => old_features = Set.new($LOADED_FEATURES.dup)
+        }
+        features = file && file[:features] || []
+        features.each{ |feature| Reloader.safe_load(feature, :force => true) }
+        $LOADED_FEATURES.delete(name) if old_features.include?(name)
+      end
+
+      def commit(name)
+        entry = {
+          :constants => ObjectSpace.new_classes(@old_entries[name][:constants]),
+          :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
+        }
+        files[name] = entry
+        @old_entries.delete(name)
+      end
+
+      def rollback(name)
+        new_constants = ObjectSpace.new_classes(@old_entries[name][:constants])
+        new_constants.each{ |klass| Reloader.remove_constant(klass) }
+        @old_entries.delete(name)
+      end
+
+      private
+
+      def files
+        @files ||= {}
+      end
+    end
+  end
+end