padrino-core 0.1.5 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.2.0

data/lib/padrino-core.rb

@@ -13,17 +13,17 @@ module Padrino
   #   Padrino.root("config", "settings.yml")
   #   # returns PADRINO_ROOT + "/config/setting.yml"
   def self.root(*args)
-    File.join(PADRINO_ROOT, *args)
+    File.expand_path(File.join(PADRINO_ROOT, *args))
   end
 
   # Helper method that return PADRINO_ENV
   def self.env
-    PADRINO_ENV.to_s
+    PADRINO_ENV.to_s.downcase.to_sym
   end
 
   # Returns the resulting rack builder mapping each 'mounted' application
   def self.application
-    raise ApplicationLoadError.new("At least one application must be mounted onto Padrino!") if self.mounted_apps.none?
+    raise ApplicationLoadError.new("At least one app must be mounted!") unless self.mounted_apps && self.mounted_apps.any?
     builder = Rack::Builder.new
     self.mounted_apps.each { |app| app.map_onto(builder) }
     builder

data/lib/padrino-core/application.rb

@@ -4,18 +4,12 @@ module Padrino
   # These subclassed applications can be easily mounted into other Padrino applications as well.
   class Application < Sinatra::Application
 
-    def logger
-      @log_stream ||= self.class.log_to_file? ? Padrino.root("log/#{PADRINO_ENV.downcase}.log") : $stdout
-      @logger     ||= Logger.new(@log_stream)
-    end
-
     class << self
       def inherited(subclass)
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
         subclass.default_configuration!
         super # Loading the subclass
         subclass.register Padrino::Routing if defined?(Padrino::Routing)
-        subclass.check_single_app
       end
 
       # Hooks into when a new instance of the application is created
@@ -30,19 +24,21 @@ module Padrino
       # Makes the routes defined in the block and in the Modules given
       # in `extensions` available to the application
       def controllers(*extensions, &block)
-        self.reset_routes!    if reload?
         instance_eval(&block) if block_given?
         include(*extensions)  if extensions.any?
       end
 
-      # Return true if the bootloader => Padrino.load! it's instatiated in the same
-      # palace of the app.
-      # Notice that <tt>signle_apps</tt> was not reloadable!
-      def single_app?
-        @_single_app
+      # Reloads the application files from all defined load paths
+      def reload!
+        reset_routes! # remove all existing user-defined application routes
+        Padrino.load_dependency(self.app_file)  # reload the app file
+        load_paths.each { |path| Padrino.load_dependencies(File.join(self.root, path)) }
       end
 
-      protected
+      # Resets application routes to only routes not defined by the user
+      def reset_routes!
+        @routes = Padrino::Application.dupe_routes
+      end
 
       # Setup the application by registering initializers, load paths and logger
       # Invoked automatically when an application is first instantiated
@@ -52,33 +48,28 @@ module Padrino
         self.calculate_paths
         self.register_initializers
         self.require_load_paths
-        self.setup_logger
+        self.disable :logging # We need do that as default because Sinatra use commonlogger.
         @_configured = true
       end
 
+      protected
+
       # Defines default settings for Padrino application
       def default_configuration!
         # Overwriting Sinatra defaults
         set :app_file, caller_files.first || $0 # Assume app file is first caller
         set :environment, PADRINO_ENV.to_sym
         set :raise_errors, true if development?
-        set :logging, !test?
+        set :logging, false#!test?
         set :sessions, true
-        set :log_to_file, !development?
-        set :reload, development?
         # Padrino specific
+        set :reload, development?
         set :app_name, self.to_s.underscore.to_sym
         set :default_builder, 'StandardFormBuilder'
-        enable :flash
+        set :flash, defined?(Rack::Flash)
         # Plugin specific
-        enable :padrino_mailer
-        enable :padrino_helpers
-      end
-
-      def check_single_app
-        @_single_app = File.identical?(self.app_file, Padrino.called_from.to_s)
-        single_message = "=> Instantiated #{File.basename(self.app_file)} in single app mode, reload is not available"
-        puts single_message if @_single_app && logging?
+        set :padrino_mailer, defined?(Padrino::Mailer)
+        set :padrino_helpers, defined?(Padrino::Helpers)
       end
 
       # Calculates any required paths after app_file and root have been properly configured
@@ -91,32 +82,23 @@ module Padrino
 
       # Requires the middleware and initializer modules to configure components
       def register_initializers
-        use Rack::Session::Cookie
-        use Rack::Flash if defined?(Rack::Flash) && flash?
-        use Padrino::Reloader unless single_app?
-        register DatabaseSetup if defined?(DatabaseSetup)
+        use Padrino::RackLogger
+        use Padrino::Reloader              if reload?
+        use Rack::Flash                    if flash?
+        register DatabaseSetup             if defined?(DatabaseSetup)
         @initializer_path ||= Padrino.root + '/config/initializers/*.rb'
         Dir[@initializer_path].each { |file| register_initializer(file) }
       end
 
       # Registers all desired padrino extension helpers/routing
       def register_framework_extensions
-        register Padrino::Mailer   if padrino_mailer?  && defined?(Padrino::Mailer)
-        register Padrino::Helpers  if padrino_helpers? && defined?(Padrino::Helpers)
+        register Padrino::Mailer   if padrino_mailer?
+        register Padrino::Helpers  if padrino_helpers?
       end
 
-      # Require all files within the application's load paths
+      # Requires all files within the application load paths
       def require_load_paths
-        load_paths.each { |path| Padrino.load_dependencies(File.join(self.root, path)) }
-      end
-
-      # Creates the log directory and redirects output to file if needed
-      def setup_logger
-        return unless logging? && log_to_file?
-        FileUtils.mkdir_p("#{Padrino.root}/log") unless File.exists?("#{Padrino.root}/log")
-        log = File.new("#{Padrino.root}/log/#{PADRINO_ENV.downcase}.log", "a+")
-        $stdout.reopen(log)
-        $stderr.reopen(log)
+        load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
       end
 
       # Returns the load_paths for the application (relative to the application root)
@@ -132,23 +114,15 @@ module Padrino
         @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
       end
 
-      # Resets application routes for use in reloading the application
-      # This performs a basic routes reload (compatible with sinatra edge)
-      def reset_routes!
-        return if single_app? # Don't reset routes for single app
-        @routes = Padrino::Application.dupe_routes
-        load(self.app_file)
-      end
-
       # Registers an initializer with the application
       # register_initializer('/path/to/initializer')
       def register_initializer(file_path)
-        Padrino.load_dependencies(file_path)
+        Padrino.require_dependencies(file_path)
         file_class = File.basename(file_path, '.rb').camelize
         register "#{file_class}Initializer".constantize
       rescue NameError => e
-        puts "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!" if logging?
-        puts "   Initializer error was '#{e.message}'" if logging?
+        logger.error "The module '#{file_class}Initializer' (#{file_path}) didn't loaded properly!"
+        logger.error "   Initializer error was '#{e.message}'"
       end
     end
   end

data/lib/padrino-core/caller.rb

@@ -1,17 +1,23 @@
 module Padrino
   PADRINO_IGNORE_CALLERS = [
-    %r{/padrino-.*$},            # all padrino code
-    %r{/sinatra},                # all sinatra code
-    %r{lib/tilt.*\.rb$},         # all tilt code
-    %r{\(.*\)},                  # generated code
-    %r{shoulda/context\.rb$},    # shoulda hacks
-    %r{mocha/integration},       # mocha hacks
-    %r{test/unit},               # test unit hacks
-    %r{rake_test_loader\.rb},    # rake hacks
-    %r{custom_require\.rb$},     # rubygems require hacks
-    %r{active_support},          # active_support require hacks
-    %r{/thor},                   # thor require hacks
-  ]
+   %r{lib/padrino-.*$},   # all padrino code
+   %r{/padrino-.*/(lib|bin)},   # all padrino code
+   %r{/bin/padrino$},           # all padrino code
+   %r{/sinatra},                # all sinatra code
+   %r{lib/tilt.*\.rb$},         # all tilt code
+   %r{lib/rack.*\.rb$},         # all rack code
+   %r{lib/mongrel.*\.rb$},      # all mongrel code
+   %r{lib/shotgun.*\.rb$},      # all shotgun lib
+   %r{bin/shotgun$},            # shotgun binary
+   %r{\(.*\)},                  # generated code
+   %r{shoulda/context\.rb$},    # shoulda hacks
+   %r{mocha/integration},       # mocha hacks
+   %r{test/unit},               # test unit hacks
+   %r{rake_test_loader\.rb},    # rake hacks
+   %r{custom_require\.rb$},     # rubygems require hacks
+   %r{active_support},          # active_support require hacks
+   %r{/thor},                   # thor require hacks
+  ] unless defined?(PADRINO_IGNORE_CALLERS)
 
   # add rubinius (and hopefully other VM impls) ignore patterns ...
   PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)

data/lib/padrino-core/loader.rb

@@ -2,13 +2,20 @@ module Padrino
   class << self
     # Requires necessary dependencies as well as application files from root lib and models
     def load!
-      return if loaded?
+      return false if loaded?
       @_called_from = first_caller
       load_required_gems # load bundler gems
-      load_dependencies("#{root}/config/apps.rb", "#{root}/config/database.rb") # load configuration
-      load_dependencies("#{root}/lib/**/*.rb", "#{root}/models/*.rb") # load root app dependencies
-      reload! # We need to fill our Stat::CACHE but we do that only for development
-      @_loaded = true
+      require_dependencies("#{root}/config/apps.rb", "#{root}/config/database.rb") # load configuration
+      require_dependencies("#{root}/lib/**/*.rb", "#{root}/models/*.rb") # load root app dependencies
+      Stat.reload! # We need to fill our Stat::CACHE but we do that only for development
+      Thread.current[:padrino_loaded] = true
+    end
+
+    # Method for reloading required applications and their files
+    def reload!
+      return unless Stat.changed?
+      Stat.reload! # detects the modified files
+      Padrino.mounted_apps.each { |m| m.app_object.reload! } # finally we reload all files for each app
     end
 
     # This adds the ablity to instantiate Padrino.load! after Padrino::Application definition.
@@ -18,7 +25,7 @@ module Padrino
 
     # Return true if Padrino was loaded with Padrino.load!
     def loaded?
-      @_loaded
+      Thread.current[:padrino_loaded]
     end
 
     # Attempts to require all dependencies with bundler; if this fails, uses system wide gems
@@ -27,23 +34,33 @@ module Padrino
       require_vendored_gems
     end
 
-    # Attempts to load/require all dependency libs that we need.
+    # Attempts to require all dependency libs that we need.
     # If you use this method we can perform correctly a Padrino.reload!
     #
-    # @param paths [Array] Path where is necessary require or load a dependency
-    # @example For load all our app libs we need to do:
-    #   load_dependencies("#{Padrino.root}/lib/**/*.rb")
-    def load_dependencies(*paths)
+    # ==== Parameters
+    # paths:: Path where is necessary require a dependency
+    #
+    # Example:
+    #   # For require all our app libs we need to do:
+    #   require_dependencies("#{Padrino.root}/lib/**/*.rb")
+    def require_dependencies(*paths)
       paths.each do |path|
         Dir[path].each { |file| require(file) }
       end
     end
-    alias_method :load_dependency, :load_dependencies
+    alias :require_dependency :require_dependencies
 
-    # Method for reload required classes
-    def reload!
-      Stat::reload!
+    # Attempts to load all dependency libs that we need.
+    # If you use this method we can perform correctly a Padrino.reload!
+    #
+    # ==== Parameters
+    # paths:: Path where is necessary to load a dependency
+    def load_dependencies(*paths)
+      paths.each do |path|
+        Dir[path].each { |file| load(file) }
+      end
     end
+    alias :load_dependency :load_dependencies
 
     protected
 
@@ -57,17 +74,22 @@ module Padrino
       say " ... Not Found"
     end
 
-    # Loads bundled gems if they exist
+    # Require bundled gems if they exist
     def require_vendored_gems
-      load_dependencies(root('/../vendor', 'gems', PADRINO_ENV))
-      say " (Loading bundled gems)\n"
+      require_dependencies(root('/../vendor', 'gems', PADRINO_ENV))
+      say! " (Loading bundled gems)"
     rescue LoadError => e
-      say " (Loading system gems)\n"
+      say! " (Loading system gems)"
     end
 
     # Prints out a message to the stdout if not in test environment
     def say(text)
-      print text if Padrino.env != 'test'
+      print text if Padrino.env != :test
+    end
+    
+    # Puts out a message to the stdout if not in test environment
+    def say!(text)
+      puts text if Padrino.env != :test
     end
   end
-end
+end

data/lib/padrino-core/logger.rb

@@ -0,0 +1,204 @@
+module Padrino
+
+  # Setup a new logger
+  def self.setup_logger!
+    case Padrino.env
+      when :production
+        FileUtils.mkdir_p("#{Padrino.root}/log") unless File.exists?("#{Padrino.root}/log")
+        log = File.new("#{Padrino.root}/log/#{PADRINO_ENV.downcase}.log", "a+")
+        Thread.current[:padrino_logger] = Padrino::Logger.new(:log_level => :error, :stream => log)
+      when :development
+        Thread.current[:padrino_logger] = Padrino::Logger.new
+      when :test
+        Thread.current[:padrino_logger] = Padrino::Logger.new(:stream => StringIO.new)
+    end
+    Thread.current[:padrino_logger]
+  end
+
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # 
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels = {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    } unless const_defined?(:Levels)
+
+    @@mutex = {}
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Options can be:
+    # 
+    # :stream:: Either an IO object or a name of a logfile. Defaults to $stdout
+    # :log_level::
+    #   The log level from, e.g. :fatal or :info. Defaults to :debug in the
+    #   production environment and :debug otherwise.
+    # :auto_flush::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to true.
+    # :format_datetime:: Format of datetime. Defaults to: "%d/%b/%Y %H:%M:%S"
+    # :format_message:: Format of message. Defaults to: ""%s - - [%s] \"%s\"""
+    def initialize(options={})
+      @buffer            = []
+      @auto_flush        = options.has_key?(:auto_flush) ? options[:auto_flush] : true
+      @level             = options[:log_level] ? Levels[options[:log_level]] : Levels[:debug]
+      @log               = options[:stream]  || $stdout
+      @log.sync          = true
+      @mutex             = @@mutex[@log] ||= Mutex.new
+      @format_datetime   = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
+      @format_message    = options[:format_message] || "%s - [%s] \"%s\""
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @mutex.synchronize do
+        @log.write(@buffer.slice!(0..-1).join(''))
+      end
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # message:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # message:: The resulting message added to the log file.
+    def push(message = nil, level = nil)
+      self << @format_message % [level.to_s.upcase, Time.now.strftime(@format_datetime), message.to_s]
+    end
+
+    def <<(message = nil)
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+      message
+    end
+
+    # Generate the logging methods for Padrino.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # message:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        if #{number} >= level
+          message = block_given? ? yield : message
+          self.push(message, :#{name}) if #{number} >= level
+        end
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # message:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        if #{number} >= level
+          message = block_given? ? yield : message
+          self.push(message, :#{name}) if #{number} >= level
+          flush if #{number} >= level
+        end
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+  end
+  
+  # RackLogger forwards every request to an +app+ given, and
+  # logs a line in the Apache common log format to the +logger+, or
+  # rack.errors by default.
+  class RackLogger
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    # "lilith.local - - GET / HTTP/1.1 500 -"
+    #  %{%s - %s %s %s%s %s - %d %s %0.4f}
+    FORMAT = %{%s - %s %s %s%s %s - %d %s %0.4f}
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      log(env, status, header, began_at)
+      [status, header, body]
+    end
+
+    private
+
+    def log(env, status, header, began_at)
+      now = Time.now
+      length = extract_content_length(header)
+
+      logger.debug FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        status.to_s[0..3],
+        length,
+        now - began_at ]
+    end
+
+    def extract_content_length(headers)
+      headers.each do |key, value|
+        if key.downcase == 'content-length'
+          return value.to_s == '0' ? '-' : value
+        end
+      end
+      '-'
+    end
+  end
+end
+
+# Define a logger available every where in our app
+def logger
+  Thread.current[:padrino_logger] ||= Padrino::setup_logger!
+end

data/lib/padrino-core/mounter.rb

@@ -4,19 +4,21 @@ module Padrino
   # @example Mounter.new("blog_app", :app_class => "Blog").to("/blog")
   # @example Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
   class Mounter
-    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root
+    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj
+
     def initialize(name, options={})
       @name      = name.downcase
       @app_class = options[:app_class] || name.classify
       @app_file  = options[:app_file]  || locate_app_file
       @app_root  = options[:app_root]
+      @app_obj   = self.app_object
     end
 
     # Registers the mounted application onto Padrino
     # @example Mounter.new("blog_app").to("/blog")
     def to(mount_url)
-      @uri_root = mount_url
-      Padrino.mounted_apps << self
+      @uri_root  = mount_url
+      Padrino.insert_mounted_app(self)
       self
     end
 
@@ -24,22 +26,32 @@ module Padrino
     # For use in constructing a Rack application
     # @example @app.map_onto(@builder)
     def map_onto(builder)
-      self.app_class.constantize rescue require(self.app_file)
-      app_data, app_class = self, self.app_class.constantize
+      app_data, app_obj = self, @app_obj
       builder.map self.uri_root do
-        app_class.set :uri_root, app_data.uri_root
-        app_class.set :app_file, app_data.app_file
-        app_class.set :app_name, app_data.name
-        app_class.set :root,     app_data.app_root if app_data.app_root
-        run app_class
+        app_obj.set :uri_root, app_data.uri_root
+        app_obj.set :app_name, app_data.name
+        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?
+        run app_obj
       end
     end
 
+    # Return the class for the app
+    def app_object
+      app_class.constantize rescue Padrino.require_dependency(app_file)
+      app_class.constantize
+    end
+
     # Returns the determined location of the mounted application main file
     def locate_app_file
       callers_are_identical = File.identical?(Padrino.first_caller.to_s, Padrino.called_from.to_s)
       callers_are_identical ? Padrino.first_caller : Padrino.mounted_root(name, "app.rb")
     end
+
+    # Makes two Mounters equal if they have the same name and uri_root
+    def ==(other)
+      other.is_a?(Mounter) && self.name == other.name && self.uri_root == other.uri_root
+    end
   end
 
   class << self
@@ -55,6 +67,12 @@ module Padrino
       @mounted_apps ||= []
     end
 
+    # Inserts a Mounter object into the mounted applications (avoids duplicates)
+    def insert_mounted_app(mounter)
+      return false if Padrino.mounted_apps.include?(mounter)
+      Padrino.mounted_apps << mounter
+    end
+
     # Mounts the core application onto Padrino project with given app settings (file, class, root)
     # @example Padrino.mount_core("Blog")
     # @example Padrino.mount_core(:app_file => "/path/to/file", :app_class => "Blog")

data/lib/padrino-core/reloader.rb

@@ -7,7 +7,7 @@ module Padrino
   # also respects a cool down time, during which nothing will be done.
   class Reloader
 
-    def initialize(app, cooldown = 1, backend = Stat)
+    def initialize(app, cooldown = 1)
       @app = app
       @cooldown = cooldown
       @last = (Time.now - cooldown)

data/lib/padrino-core/stat.rb

@@ -17,9 +17,18 @@ module Padrino
         end
       end
 
+      def changed?
+        changed = false
+        rotation do |file, mtime|
+          previous_mtime = MTIMES[file] ||= mtime
+          changed = true if mtime > MTIMES[file]
+        end
+        changed
+      end
+
       # A safe Kernel::load, issuing the hooks depending on the results
       def safe_load(file, mtime)
-        puts "=> Reloading #{file}"
+        Padrino.say! "=> Reloading #{file}"
         load(file)
         file
       rescue LoadError, SyntaxError => ex
@@ -32,9 +41,8 @@ module Padrino
         files = [$0, *$LOADED_FEATURES].uniq
         paths = ['./', *$LOAD_PATH].uniq
 
-        files.map{|file|
-          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
-
+        files.map{ |file|
+          next if file =~ /\.(so|bundle)$/                   # cannot reload compiled files
           found, stat = figure_path(file, paths)
           next unless found && stat && mtime = stat.mtime
 

data/lib/padrino-core/support_lite.rb

@@ -11,6 +11,7 @@ Required for Padrino to run:
   * Array#extract_options!
   * Object#blank?
   * Object#present?
+  * Hash#slice, Hash#slice!
   * Hash#symbolize_keys
   * Hash#reverse_merge, Hash#reverse_merge!
   * SupportLite::OrderedHash

data/lib/padrino-core/support_lite/as_support.rb

@@ -2,7 +2,7 @@
 
 ## Class#cattr_accessor
 require 'active_support/core_ext/class/attribute_accessors' unless Class.method_defined?(:cattr_accessor)
-## Hash#symbolize_keys, Hash#reverse_merge, Hash#reverse_merge!, Hash#extract_options!
+## Hash#symbolize_keys, Hash#reverse_merge, Hash#reverse_merge!, Hash#extract_options!, Hash#slice!
 require 'active_support/core_ext/hash' unless Hash.method_defined?(:reverse_merge)
 ## String#inflectors
 require 'active_support/inflector' unless String.method_defined?(:constantize)

data/lib/padrino-core/support_lite/extlib_support.rb

@@ -24,6 +24,18 @@ unless Hash.method_defined?(:symbolize_keys)
   end
 end
 
+## Hash#slice, Hash#slice!
+unless Hash.method_defined?(:slice)
+  require 'extlib/hash'
+  class Hash
+    def slice(*keys)
+      keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+      hash = self.class.new
+      keys.each { |k| hash[k] = self[k] if has_key?(k) }
+      hash
+    end
+  end
+end
 
 ## Hash#reverse_merge, Hash#reverse_merge!
 unless Hash.method_defined?(:present?)

data/lib/padrino-core/tasks.rb

@@ -16,6 +16,7 @@ module Padrino
       method_option :port,        :type => :numeric, :aliases => "-p", :required => true, :default => 3000
       method_option :boot,        :type => :string,  :aliases => "-b", :required => true, :default => "config/boot.rb"
       method_option :daemonize,   :type => :boolean, :aliases => "-d"
+
       def start
         require File.dirname(__FILE__) + "/tasks/adapter"
         chdir(options.chdir)
@@ -47,11 +48,11 @@ module Padrino
         end
         ENV["PADRINO_ENV"] ||= environment
         puts "=> Loading #{environment} console (Padrino v.#{Padrino.version})"
-        irb   = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-        libs  = " -r irb/completion"
-        libs << " -r #{boot}"
-        libs << " -r #{File.dirname(__FILE__)}/tasks/console"
-        exec "#{irb} #{libs} --simple-prompt"
+        require 'irb'
+        require "irb/completion"
+        require boot
+        require File.dirname(__FILE__) + '/tasks/console'
+        IRB.start
       end
     end
   end

data/lib/padrino-core/tasks/console.rb

@@ -1,7 +1,6 @@
 # Reloads classes
 def reload!
   Padrino.reload!
-  true
 end
 
 # Show applications
@@ -17,5 +16,6 @@ end
 # Load apps
 Padrino.mounted_apps.each do |app|
   puts "=> Loading Application #{app.name}"
-  Padrino.load_dependency(app.app_file)
-end
+  Padrino.require_dependency(app.app_file)
+  app.app_object.setup_application!
+end

data/padrino-core.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-core}
-  s.version = "0.1.5"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2009-11-23}
+  s.date = %q{2009-11-24}
   s.default_executable = %q{padrino}
   s.description = %q{The Padrino core gem required for use of this framework}
   s.email = %q{nesquena@gmail.com}
@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
      "lib/padrino-core/application.rb",
      "lib/padrino-core/caller.rb",
      "lib/padrino-core/loader.rb",
+     "lib/padrino-core/logger.rb",
      "lib/padrino-core/mounter.rb",
      "lib/padrino-core/reloader.rb",
      "lib/padrino-core/stat.rb",
@@ -44,11 +45,14 @@ Gem::Specification.new do |s|
      "padrino-core.gemspec",
      "test/fixtures/apps/.components",
      "test/fixtures/apps/.gitignore",
-     "test/fixtures/apps/app.rb",
-     "test/fixtures/apps/multi.rb",
+     "test/fixtures/apps/complex.rb",
+     "test/fixtures/apps/simple.rb",
      "test/helper.rb",
+     "test/test_application.rb",
      "test/test_padrino_core.rb",
-     "test/test_padrino_mounter.rb"
+     "test/test_padrino_mounter.rb",
+     "test/test_reloader_complex.rb",
+     "test/test_reloader_simple.rb"
   ]
   s.homepage = %q{http://github.com/padrino/padrino-framework/tree/master/padrino-core}
   s.rdoc_options = ["--charset=UTF-8"]

data/test/fixtures/apps/complex.rb

@@ -0,0 +1,29 @@
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
+
+module LibDemo
+  module_function
+  
+  def give_me_a_random
+    @rand ||= rand(100)
+  end
+end
+
+class Complex1Demo < Padrino::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+end
+
+class Complex2Demo < Padrino::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+end
+
+Complex1Demo.controllers do
+  get(""){ "Given random #{LibDemo.give_me_a_random}" }
+end
+
+Complex2Demo.controllers do
+  get(""){ "The magick number is: 88!" } # Change only the number!!!
+end
+
+Padrino.load!

data/test/fixtures/apps/simple.rb

@@ -0,0 +1,23 @@
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
+# Remove this comment if you want do some like this: ruby PADRINO_ENV=test app.rb
+# 
+# require 'rubygems'
+# require 'lib/padrino-core'
+# 
+# Use this for prevent (when reload is in use) to re run the server.
+# 
+# if Padrino.load!
+#   SingleDemo.run!
+# end
+
+class SimpleDemo < Padrino::Application
+  set :reload, true
+end
+
+SimpleDemo.controllers do
+  get "/" do
+    'The magick number is: 66!' # Change only the number!!!
+  end
+end
+
+Padrino.load! # Remove this if you will run the app standalone

data/test/helper.rb

@@ -7,19 +7,17 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rubygems'
 require 'padrino-core'
 require 'test/unit'
-require 'shoulda'
-require 'mocha'
 require 'rack/test'
-require 'webrat'
+require 'rack'
+require 'shoulda'
+
+class Padrino::Application
+  # Allow assertions in request context
+  include Test::Unit::Assertions
+end
 
 class Test::Unit::TestCase
   include Rack::Test::Methods
-  include Webrat::Methods
-  include Webrat::Matchers
-
-  Webrat.configure do |config|
-    config.mode = :rack
-  end
 
   # Test App
   class PadrinoTestApp < Padrino::Application; end
@@ -46,24 +44,27 @@ class Test::Unit::TestCase
     assert File.exist?(file), "File '#{file}' does not exist!"
     assert_match pattern, File.read(file)
   end
-end
-
-class Object
-  # Silences the output by redirecting to stringIO
-  # silence_logger { ...commands... } => "...output..."
-  def silence_logger(&block)
-    orig_stdout = $stdout
-    $stdout = log_buffer = StringIO.new
-    block.call
-    $stdout = orig_stdout
-    log_buffer.rewind && log_buffer.read
-  end
-end
-
-module Webrat
-  module Logging
-    def logger # :nodoc:
-      @logger = nil
+  
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super
     end
   end
-end
+
+  alias :response :last_response
+end
+# 
+# class Object
+#   # Silences the output by redirecting to stringIO
+#   # silence_logger { ...commands... } => "...output..."
+#   def silence_logger(&block)
+#     orig_stdout = $stdout
+#     $stdout = log_buffer = StringIO.new
+#     block.call
+#     $stdout = orig_stdout
+#     log_buffer.rewind && log_buffer.read
+#   end
+# end

data/test/test_application.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestApplication < Test::Unit::TestCase
+
+  context 'for application functionality' do
+
+    should 'check default options' do
+      assert_match %r{test/helper.rb}, PadrinoTestApp.app_file
+      assert_equal :test, PadrinoTestApp.environment
+      assert_equal Padrino.root("views"), PadrinoTestApp.views
+      assert PadrinoTestApp.raise_errors
+      assert !PadrinoTestApp.logging
+      assert PadrinoTestApp.sessions
+      assert 'PadrinoTestApp', PadrinoTestApp.app_name
+    end
+
+    should 'check padrino specific options' do
+      assert !PadrinoTestApp.instance_variable_get(:@_configured)
+      PadrinoTestApp.send(:setup_application!)
+      assert PadrinoTestApp.instance_variable_get(:@_configured)
+      assert !PadrinoTestApp.send(:find_view_path)
+      assert !PadrinoTestApp.reload?
+      assert 'padrino_test_app', PadrinoTestApp.app_name
+      assert 'StandardFormBuilder', PadrinoTestApp.default_builder
+      assert !PadrinoTestApp.flash
+      assert !PadrinoTestApp.padrino_mailer
+      assert !PadrinoTestApp.padrino_helpers
+    end
+  end
+end

data/test/test_padrino_core.rb

@@ -13,7 +13,7 @@ class TestPadrinoCore < Test::Unit::TestCase
     end
 
     should 'validate global helpers' do
-      assert_equal "test", Padrino.env
+      assert_equal :test, Padrino.env
       assert_match /\/test/, Padrino.root
     end
     

data/test/test_padrino_mounter.rb

@@ -27,15 +27,15 @@ class TestPadrinoMounter < Test::Unit::TestCase
       mounter.to("/test")
       assert_equal "test", mounter.name
       assert_equal "Test", mounter.app_class
-      assert_equal __FILE__, mounter.app_file
+      assert_match %r{test/apps/test/app.rb}, mounter.app_file
       assert_equal "/test", mounter.uri_root
       assert_nil mounter.app_root
     end
 
     should 'mount an app' do
-      class AnApp < Padrino::Application; end
-      
+      class ::AnApp < Padrino::Application; end
       Padrino.mount_core("an_app")
+      assert_equal AnApp, Padrino.mounted_apps.first.app_obj
       assert_equal ["core"], Padrino.mounted_apps.collect(&:name)
     end
     
@@ -43,18 +43,25 @@ class TestPadrinoMounter < Test::Unit::TestCase
       mounter = Padrino.mount_core("test")
       assert_equal "core", mounter.name
       assert_equal "Test", mounter.app_class
+      assert_equal Test, mounter.app_obj
       assert_equal Padrino.root('app/app.rb'), mounter.app_file
       assert_equal "/", mounter.uri_root
       assert_equal Padrino.root, mounter.app_root
     end
 
     should 'mount multiple apps' do
-      class OneApp < Padrino::Application; end
-      class TwoApp < Padrino::Application; end
+      class ::OneApp < Padrino::Application; end
+      class ::TwoApp < Padrino::Application; end
       
+      Padrino.mount("one_app").to("/one_app")
+      Padrino.mount("two_app").to("/two_app")
+      # And testing no duplicates
       Padrino.mount("one_app").to("/one_app")
       Padrino.mount("two_app").to("/two_app")
 
+      assert_equal OneApp, Padrino.mounted_apps[0].app_obj
+      assert_equal TwoApp, Padrino.mounted_apps[1].app_obj
+      assert_equal 2, Padrino.mounted_apps.size, "should not mount duplicate apps"
       assert_equal ["one_app", "two_app"], Padrino.mounted_apps.collect(&:name)
     end
     
@@ -74,9 +81,9 @@ class TestPadrinoMounter < Test::Unit::TestCase
       end
       
       get '/demo_1'
-      assert_contain "Im Demo 1"
-      visit '/demo_2'
-      assert_contain "Im Demo 2"
+      assert_equal "Im Demo 1", body
+      get '/demo_2'
+      assert_equal "Im Demo 2", body
     end
   end
 end

data/test/test_reloader_complex.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/helper'
+require 'fixtures/apps/complex'
+
+class TestComplexReloader < Test::Unit::TestCase
+
+  context 'for complex reload functionality' do
+
+    should 'correctly instantiate Complex(1-2)Demo fixture' do
+      Padrino.mounted_apps.clear
+      Padrino.mount("complex_1_demo").to("/complex_1_demo")
+      Padrino.mount("complex_2_demo").to("/complex_2_demo")
+      assert_equal ["complex_1_demo", "complex_2_demo"], Padrino.mounted_apps.collect(&:name)
+      assert Complex1Demo.reload?
+      assert Complex2Demo.reload?
+      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
+      assert_match %r{fixtures/apps/complex.rb}, Complex2Demo.app_file
+    end
+
+    should 'correctly reload Complex(1-2)Demo fixture' do
+      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
+      @app = Padrino.application
+
+      get "/"
+      assert_equal 404, status
+
+      get "/complex_1_demo"
+      assert_equal "Given random #{LibDemo.give_me_a_random}", body
+
+      get "/complex_2_demo"
+      assert_equal 200, status
+
+      get "/complex_1_demo/old"
+      assert_equal 200, status
+
+      get "/complex_2_demo/old"
+      assert_equal 200, status
+
+      new_phrase =  "The magick number is: #{rand(100)}!"
+      buffer = File.read(Complex1Demo.app_file).gsub!(/The magick number is: \d+!/, new_phrase)
+      File.open(Complex1Demo.app_file, "w") { |f| f.write(buffer) }
+      sleep 1.2 # We need at least a cooldown of 1 sec.
+      get "/complex_2_demo"
+      assert_equal new_phrase, body
+
+      # Re-Check that we didn't forget any route
+      get "/complex_1_demo"
+      assert_equal "Given random #{LibDemo.give_me_a_random}", body
+
+      get "/complex_2_demo"
+      assert_equal 200, status
+
+      get "/complex_1_demo/old"
+      assert_equal 200, status
+
+      get "/complex_2_demo/old"
+      assert_equal 200, status
+    end
+  end
+end

data/test/test_reloader_simple.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/helper'
+require 'fixtures/apps/simple'
+
+class TestSimpleReloader < Test::Unit::TestCase
+
+  context 'for simple reset functionality' do
+
+    should 'reset routes' do
+      mock_app do
+        1.step(10).each do |i|
+          get("/#{i}") { "Foo #{i}" }
+        end
+      end
+      1.step(10).each do |i|
+        get "/#{i}"
+        assert_equal "Foo #{i}", body
+      end
+      @app.reset_routes!
+      1.step(10).each do |i|
+        get "/#{i}"
+        assert_equal 404, status
+      end
+    end
+  end
+
+  context 'for simple reload functionality' do
+
+    should 'correctly instantiate SimpleDemo fixture' do
+      Padrino.mounted_apps.clear
+      Padrino.mount_core("simple_demo")
+      assert_equal ["core"], Padrino.mounted_apps.collect(&:name)
+      assert SimpleDemo.reload?
+      assert_match %r{fixtures/apps/simple.rb}, SimpleDemo.app_file
+    end
+
+    should 'correctly reload SimpleDemo fixture' do
+      @app = SimpleDemo
+      get "/"
+      assert_equal 200, status
+      new_phrase =  "The magick number is: #{rand(100)}!"
+      buffer = File.read(SimpleDemo.app_file).gsub!(/The magick number is: \d+!/, new_phrase)
+      File.open(SimpleDemo.app_file, "w") { |f| f.write(buffer) }
+      sleep 1.2 # We need at least a cooldown of 1 sec.
+      get "/"
+      assert_equal new_phrase, body
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-23 00:00:00 -08:00
+date: 2009-11-24 00:00:00 -08:00
 default_executable: padrino
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -115,6 +115,7 @@ files:
 - lib/padrino-core/application.rb
 - lib/padrino-core/caller.rb
 - lib/padrino-core/loader.rb
+- lib/padrino-core/logger.rb
 - lib/padrino-core/mounter.rb
 - lib/padrino-core/reloader.rb
 - lib/padrino-core/stat.rb
@@ -130,11 +131,14 @@ files:
 - padrino-core.gemspec
 - test/fixtures/apps/.components
 - test/fixtures/apps/.gitignore
-- test/fixtures/apps/app.rb
-- test/fixtures/apps/multi.rb
+- test/fixtures/apps/complex.rb
+- test/fixtures/apps/simple.rb
 - test/helper.rb
+- test/test_application.rb
 - test/test_padrino_core.rb
 - test/test_padrino_mounter.rb
+- test/test_reloader_complex.rb
+- test/test_reloader_simple.rb
 has_rdoc: true
 homepage: http://github.com/padrino/padrino-framework/tree/master/padrino-core
 licenses: []

data/test/fixtures/apps/app.rb

@@ -1,15 +0,0 @@
-PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
-require 'rubygems'
-require 'sinatra/base'
-require 'lib/padrino-core'
-
-class SingleDemo < Padrino::Application; end
-
-SingleDemo.controllers do
-  get "/test" do
-    'This should work'
-  end
-end
-
-Padrino.mount_core("single_demo")
-Padrino.load!

data/test/fixtures/apps/multi.rb

@@ -1,27 +0,0 @@
-PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
-require 'sinatra/base'
-require 'padrino-core'
-
-class Multi1Demo < Padrino::Application
-  disable :padrino_routing
-  disable :padrino_mailer
-  disable :padrino_helpers
-  
-  get "" do
-    "Im Core1Demo"
-  end
-end
-
-class Mutli2Demo < Padrino::Application
-  disable :padrino_routing
-  disable :padrino_mailer
-  disable :padrino_helpers
-  
-  get "" do
-    "Im Core2Demo"
-  end
-end
-
-Padrino.mount("multi_1_demo").to("/multi_1_demo")
-Padrino.mount("multi_2_demo").to("/multi_2_demo")
-Padrino.load!