padrino-core 0.11.4 → 0.12.0.rc1

data/lib/padrino-core/reloader.rb

@@ -1,4 +1,6 @@
 require 'pathname'
+require 'padrino-core/reloader/rack'
+require 'padrino-core/reloader/storage'
 
 module Padrino
   ##
@@ -12,330 +14,233 @@ module Padrino
     # Please note that this will not reload files in the background, and does so
     # only when explicitly invoked.
     #
+    extend self
 
     # The modification times for every file in a project.
-    MTIMES          = {}
-    # The list of files loaded as part of a project.
-    LOADED_FILES    = {}
-    # The list of object constants and classes loaded as part of the project.
-    LOADED_CLASSES  = {}
+    MTIMES = {}
 
-    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
-
-      ##
-      # Specified constants can be excluded from the code unloading process.
-      #
-      def exclude_constants
-        @_exclude_constants ||= Set.new
-      end
-
-      ##
-      # Specified constants can be configured to be reloaded on every request.
-      # Default included constants are: [none]
-      #
-      def include_constants
-        @_include_constants ||= Set.new
-      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 = mounted_apps_of(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
-          end
-        end
-      end
-
-      ##
-      # Remove files and classes loaded with stat
-      #
-      def clear!
-        clear_modification_times
-        clear_loaded_classes
-        clear_loaded_files_and_features
-      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]
-          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 do |klass|
-          klass._orig_klass_name.split('::')[0]
-        end
-
-        klasses = klasses | Padrino.mounted_apps.map { |app| app.app_class }
-        Padrino::Reloader.exclude_constants.merge(klasses)
-      end
-
-      ##
-      # A safe Kernel::require which issues the necessary hooks depending on results
-      #
-      def safe_load(file, options={})
-        began_at = Time.now
-        force    = options[:force]
-        file     = figure_path(file)
-        reload   = should_reload?(file)
-        m_time   = modification_time(file)
-
-        return if !force && m_time && !reload
-
-        remove_loaded_file_classes(file)
-        remove_loaded_file_features(file)
-
-        # Duplicate objects and loaded features before load file
-        klasses = ObjectSpace.classes
-        files   = Set.new($LOADED_FEATURES.dup)
-
-        reload_deps_of_file(file)
-
-        # And finally load the specified file
-        begin
-          logger.devel :loading, began_at, file if !reload
-          logger.debug :reload,  began_at, file if  reload
+    ##
+    # 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 ||= Set.new %w(test spec tmp features config public db).map{ |path| Padrino.root(path) }
+    end
 
-          $LOADED_FEATURES.delete(file) if files.include?(file)
-          Padrino::Utils.silence_output
-          loaded = false
-          require(file)
-          loaded = true
-          update_modification_time(file)
-        rescue SyntaxError => e
-          logger.error "Cannot require #{file} due to a syntax error: #{e.message}"
-        ensure
-          Padrino::Utils.unsilence_output
-          new_constants = ObjectSpace.new_classes(klasses)
-          if loaded
-            process_loaded_file(:file      => file,
-                                :constants => new_constants,
-                                :files     => files)
-          else
-            logger.devel "Failed to load #{file}; removing partially defined constants"
-            unload_constants(new_constants)
-          end
-        end
-      end
+    ##
+    # Specified constants can be excluded from the code unloading process.
+    #
+    def exclude_constants
+      @_exclude_constants ||= Set.new
+    end
 
-      ##
-      # 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
+    ##
+    # Specified constants can be configured to be reloaded on every request.
+    # Default included constants are: [none]
+    #
+    def include_constants
+      @_include_constants ||= Set.new
+    end
 
-      ##
-      # Removes the specified class and constant.
-      #
-      def remove_constant(const)
-        return if exclude_constants.any? { |c| const._orig_klass_name.index(c) == 0 } &&
-                 !include_constants.any? { |c| const._orig_klass_name.index(c) == 0 }
-        begin
-          parts  = const.to_s.sub(/^::(Object)?/, 'Object::').split('::')
-          object = parts.pop
-          base   = parts.empty? ? Object : Inflector.constantize(parts * '::')
-          base.send :remove_const, object
-          logger.devel "Removed constant: #{const} from #{base}"
-        rescue NameError; end
+    ##
+    # Reload apps and files with changes detected.
+    #
+    def reload!
+      rotation do |file|
+        next unless file_changed?(file)
+        reload_special(file) || reload_regular(file)
       end
+    end
 
-      private
+    ##
+    # Remove files and classes loaded with stat
+    #
+    def clear!
+      MTIMES.clear
+      Storage.clear!
+    end
 
-      ###
-      # Clear instance variables that keep track of # loaded features/files/mtimes.
-      #
-      def clear_modification_times
-        MTIMES.clear
+    ##
+    # Returns true if any file changes are detected.
+    #
+    def changed?
+      rotation do |file|
+        break true if file_changed?(file)
       end
+    end
 
-      def clear_loaded_classes
-        LOADED_CLASSES.each do |file, klasses|
-          klasses.each { |klass| remove_constant(klass) }
-          LOADED_CLASSES.delete(file)
-        end
+    ##
+    # We lock dependencies sets to prevent reloading of protected constants
+    #
+    def lock!
+      klasses = ObjectSpace.classes do |klass|
+        klass._orig_klass_name.split('::').first
       end
+      klasses |= Padrino.mounted_apps.map(&:app_class)
+      exclude_constants.merge(klasses)
+    end
 
-      def clear_loaded_files_and_features
-        LOADED_FILES.each do |file, dependencies|
-          dependencies.each { |dependency| $LOADED_FEATURES.delete(dependency) }
-          $LOADED_FEATURES.delete(file)
+    ##
+    # A safe Kernel::require which issues the necessary hooks depending on results
+    #
+    def safe_load(file, options={})
+      began_at = Time.now
+      file     = figure_path(file)
+      return unless options[:force] || file_changed?(file)
+
+      Storage.prepare(file) # might call #safe_load recursively
+      logger.debug(file_new?(file) ? :loading : :reload, began_at, file)
+      begin
+        with_silence{ require(file) }
+        Storage.commit(file)
+        update_modification_time(file)
+      rescue Exception => e
+        unless options[:cyclic]
+          logger.error "#{e.class}: #{e.message}; #{e.backtrace.first}"
+          logger.error "Failed to load #{file}; removing partially defined constants"
         end
+        Storage.rollback(file)
+        raise e
       end
+    end
 
-      ###
-      # Macro for mtime query.
-      #
-      def modification_time(file)
-        MTIMES[file]
-      end
+    ##
+    # Removes the specified class and constant.
+    #
+    def remove_constant(const)
+      return if constant_excluded?(const)
+      base, _, object = const.to_s.rpartition('::')
+      base = base.empty? ? Object : base.constantize
+      base.send :remove_const, object
+      logger.devel "Removed constant #{const} from #{base}"
+    rescue NameError
+    end
 
-      ###
-      # Macro for mtime update.
-      #
-      def update_modification_time(file)
-        MTIMES[file] = File.mtime(file)
-      end
+    ##
+    # Returns the list of special tracked files for Reloader.
+    #
+    def special_files
+      @special_files ||= Set.new
+    end
 
-      ###
-      # Tracks loaded file features/classes/constants:
-      #
-      def process_loaded_file(*args)
-        options       = args.extract_options!
-        new_constants = options[:constants]
-        files         = options[:files]
-        file          = options[:file]
+    ##
+    # Sets the list of special tracked files for Reloader.
+    #
+    def special_files=(files)
+      @special_files = Set.new(files)
+    end
 
-        # Store the file details
-        LOADED_CLASSES[file] = new_constants
-        LOADED_FILES[file]   = Set.new($LOADED_FEATURES) - files - [file]
+    private
 
-        # Track only features in our Padrino.root
-        LOADED_FILES[file].delete_if { |feature| !in_root?(feature) }
+    ##
+    # Returns absolute path of the file.
+    #
+    def figure_path(file)
+      return file if Pathname.new(file).absolute?
+      $LOAD_PATH.each do |path|
+        found = File.join(path, file)
+        return File.expand_path(found) if File.file?(found)
       end
+      file
+    end
 
-      ###
-      # Unloads all constants in new_constants.
-      #
-      def unload_constants(new_constants)
-        new_constants.each { |klass| remove_constant(klass) }
+    ##
+    # Reloads the file if it's special. For now it's only I18n locale files.
+    #
+    def reload_special(file)
+      return unless special_files.any?{ |f| File.identical?(f, file) }
+      if defined?(I18n)
+        began_at = Time.now
+        I18n.reload!
+        update_modification_time(file)
+        logger.debug :reload, began_at, file
       end
+      true
+    end
 
-      ###
-      # Safe load dependencies of a file.
-      #
-      def reload_deps_of_file(file)
-        if features = LOADED_FILES.delete(file)
-          features.each { |feature| safe_load(feature, :force => true) }
+    ##
+    # Reloads ruby file and applications dependent on it.
+    #
+    def reload_regular(file)
+      apps = mounted_apps_of(file)
+      if apps.present?
+        apps.each { |app| app.app_obj.reload! }
+        update_modification_time(file)
+      else
+        safe_load(file)
+        Padrino.mounted_apps.each do |app|
+          app.app_obj.reload! if app.app_obj.dependencies.include?(file)
         end
       end
+    end
 
-      ##
-      # Check if file was changed or if force a reload.
-      #
-      def should_reload?(file)
-        MTIMES[file] && File.mtime(file) > MTIMES[file]
-      end
+    ###
+    # Macro for mtime update.
+    #
+    def update_modification_time(file)
+      MTIMES[file] = File.mtime(file)
+    end
 
-      ##
-      # Removes all classes declared in the specified file.
-      #
-      def remove_loaded_file_classes(file)
-        if klasses = LOADED_CLASSES.delete(file)
-          klasses.each { |klass| remove_constant(klass) }
-        end
-      end
+    ###
+    # Returns true if the file is new or it's modification time changed.
+    #
+    def file_changed?(file)
+      file_new?(file) || File.mtime(file) > MTIMES[file]
+    end
 
-      ##
-      # Remove all loaded fatures with our file.
-      #
-      def remove_loaded_file_features(file)
-        if features = LOADED_FILES[file]
-          features.each { |feature| $LOADED_FEATURES.delete(feature) }
-        end
-      end
+    ###
+    # Returns true if the file is new.
+    #
+    def file_new?(file)
+      MTIMES[file].nil?
+    end
 
-      ##
-      # Return the mounted_apps providing the app location.
-      # Can be an array because in one app.rb we can define multiple Padrino::Application.
-      #
-      def mounted_apps_of(file)
-        file = figure_path(file)
-        Padrino.mounted_apps.find_all { |app| File.identical?(file, app.app_file) }
-      end
+    ##
+    # Return the mounted_apps providing the app location.
+    # Can be an array because in one app.rb we can define multiple Padrino::Application.
+    #
+    def mounted_apps_of(file)
+      Padrino.mounted_apps.select { |app| File.identical?(file, app.app_file) }
+    end
 
-      ##
-      # Returns true if file is in our Padrino.root.
-      #
-      def in_root?(file)
-        # This is better but slow:
-        #   Pathname.new(Padrino.root).find { |f| File.identical?(Padrino.root(f), figure_path(file)) }
-        figure_path(file).index(Padrino.root) == 0
+    ##
+    # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
+    # and monitors them for any changes.
+    #
+    def rotation
+      files_for_rotation.each do |file|
+        file = File.expand_path(file)
+        next if Reloader.exclude.any? { |base| file.start_with?(base) } || !File.file?(file)
+        yield file
       end
+      nil
+    end
 
-      ##
-      # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
-      # and monitors them for any changes.
-      #
-      def rotation
-        files_for_rotation.uniq.map do |file|
-          file = File.expand_path(file)
-          next if Padrino::Reloader.exclude.any? { |base| file.index(base) == 0 } || !File.exist?(file)
-          yield file, File.mtime(file)
-        end.compact
-      end
+    ##
+    # Creates an array of paths for use in #rotation.
+    #
+    def files_for_rotation
+      files = Set.new
+      Padrino.load_paths.each{ |path| files += Dir.glob("#{path}/**/*.rb") }
+      Padrino.mounted_apps.each do |app|
+        files << app.app_file
+        files += app.app_obj.dependencies
+      end
+      files + special_files
+    end
 
-      ##
-      # Creates an array of paths for use in #rotation.
-      #
-      def files_for_rotation
-        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
-      end
-    end # self
+    def constant_excluded?(const)
+      (exclude_constants - include_constants).any?{ |c| const._orig_klass_name.start_with?(c) }
+    end
 
     ##
-    # 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.
+    # Disables output, yields block, switches output back.
     #
-    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
+    def with_silence
+      verbosity_level, $-v = $-v, nil
+      yield
+    ensure
+      $-v = verbosity_level
     end
   end
 end

data/lib/padrino-core/router.rb

@@ -62,14 +62,15 @@ module Padrino
       host  = Regexp.new("^#{Regexp.quote(host)}$", true, 'n') unless host.nil? || host.is_a?(Regexp)
 
       @mapping << [host, path, match, app]
-      sort!
     end
 
     # The call handler setup to route a request given the mappings specified.
     def call(env)
+      began_at = Time.now
       path_info = env["PATH_INFO"].to_s
       script_name = env['SCRIPT_NAME']
       http_host = env['HTTP_HOST']
+      last_result = nil
 
       @mapping.each do |host, path, match, app|
         next unless host.nil? || http_host =~ host
@@ -78,18 +79,16 @@ module Padrino
 
         rest = "/" if rest.empty?
 
-        return app.call(
-          env.merge(
-            'SCRIPT_NAME' => (script_name + path),
-            'PATH_INFO'   => rest))
-      end
-      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path_info}"]]
-    end
-
-    private
+        last_result = app.call(env.merge('SCRIPT_NAME' => script_name + path, 'PATH_INFO' => rest))
 
-    def sort!
-      @mapping = @mapping.sort_by { |h, p, m, a| -p.size }
+        cascade_setting = app.respond_to?(:cascade) ? app.cascade : true
+        cascade_statuses = cascade_setting.respond_to?(:include?) ? cascade_setting : Mounter::DEFAULT_CASCADE
+        break unless cascade_setting && cascade_statuses.include?(last_result[0])
+      end
+      last_result || begin
+        Padrino::Logger::Rack.new(nil,'/').send(:log, env, 404, {}, began_at) if logger.debug?
+        [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path_info}"]]
+      end
     end
   end
 end

data/lib/padrino-core/server.rb

@@ -31,6 +31,11 @@ module Padrino
         FileUtils.mkdir_p(File.dirname(options[:pid]))
       end
       options[:server] = detect_rack_handler if options[:server].blank?
+      if options[:options].is_a?(Array)
+        parsed_server_options = options.delete(:options).map { |opt| opt.split('=', 2) }.flatten
+        server_options = Hash[*parsed_server_options].symbolize_keys!
+        options.merge!(server_options)
+      end
       new(options, app).start
     end
 

data/lib/padrino-core/support_lite.rb

@@ -4,6 +4,7 @@
 require 'active_support/core_ext/module/aliasing'           # alias_method_chain
 require 'active_support/core_ext/hash/keys'                 # symbolize_keys
 require 'active_support/core_ext/hash/reverse_merge'        # reverse_merge
+require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/slice'                # slice
 require 'active_support/core_ext/object/blank'              # present?
 require 'active_support/core_ext/array/extract_options'     # extract_options
@@ -199,27 +200,41 @@ end
 #   puts help.red.bold
 #
 class String
-  def self.colors
-    @_colors ||= {
-      :clear   => 0,
-      :bold    => 1,
-      :black   => 30,
-      :red     => 31,
-      :green   => 32,
-      :yellow  => 33,
-      :blue    => 34,
-      :magenta => 35,
-      :cyan    => 36,
-      :white   => 37
-    }
+  # colorize(:red)
+  def colorize(color)
+    Colorizer.send(color, self)
   end
 
-  colors.each do |color, value|
-    define_method(color) do
-      ["\e[", value.to_s, "m", self, "\e[", self.class.colors[:clear], "m"] * ''
+  # Used to colorize strings for the shell
+  class Colorizer
+    # Returns colors integer mapping
+    def self.colors
+      @_colors ||= {
+        :clear   => 0,
+        :bold    => 1,
+        :black   => 30,
+        :red     => 31,
+        :green   => 32,
+        :yellow  => 33,
+        :blue    => 34,
+        :magenta => 35,
+        :cyan    => 36,
+        :white   => 37
+      }
+    end
+
+    # Defines class level color methods
+    # i.e  Colorizer.red("hello")
+    class << self
+      Colorizer.colors.each do |color, value|
+        define_method(color) do |target|
+          "\e[#{value}m" << target << "\e[0m"
+         end
+      end
     end
   end
 
+  # Strip unnecessary indentation of the front of a string
   def undent
     gsub(/^.{#{slice(/^ +/).size}}/, '')
   end
@@ -242,19 +257,3 @@ I18n.load_path += Dir["#{File.dirname(__FILE__)}/locale/*.yml"] if defined?(I18n
 # Used to determine if this file has already been required
 #
 module SupportLite; end
-
-module Padrino
-  class Utils
-    ###
-    # Silences output verbosity level so load
-    # errors are not visible when safe_load(file)
-    #
-    def self.silence_output
-      @verbosity_level, $-v = $-v, nil
-    end
-
-    def self.unsilence_output
-      $-v = @verbosity_level
-    end
-  end
-end

data/lib/padrino-core/version.rb

@@ -6,7 +6,7 @@
 #
 module Padrino
   # The version constant for the current version of Padrino.
-  VERSION = '0.11.4' unless defined?(Padrino::VERSION)
+  VERSION = '0.12.0.rc1' unless defined?(Padrino::VERSION)
 
   #
   # The current Padrino version.