padrino-core 0.6.3 → 0.6.7

data/lib/padrino-core/caller.rb

@@ -19,16 +19,22 @@ module Padrino
    %r{/thor},                   # thor require hacks
   ] unless defined?(PADRINO_IGNORE_CALLERS)
 
-  # add rubinius (and hopefully other VM impls) ignore patterns ...
+  ##
+  # Add rubinius (and hopefully other VM impls) ignore patterns ...
+  # 
   PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
 
+  ##
   # Returns the filename for the file that is the direct caller (first caller)
+  # 
   def self.first_caller
     caller_files.first
   end
 
+  ##
   # Like Kernel#caller but excluding certain magic entries and without
   # line / method information; the resulting array contains filenames only.
+  # 
   def self.caller_files
     caller_locations.map { |file,line| file }
   end
@@ -38,4 +44,4 @@ module Padrino
       map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
       reject { |file,line| PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern } }
   end
-end
+end # Padrino

data/lib/padrino-core/cli.rb

@@ -41,6 +41,7 @@ module Padrino
       method_option :environment, :type => :string, :aliases => "-e", :required => true, :default => :development
       method_option :task_list,   :type => :string, :aliases => "-T"  # Only for accept rake
       def rake(task="")
+        ENV['PADRINO_LOG_LEVEL'] ||= "test"
         boot = check_boot
         return unless boot
         require 'rake'
@@ -95,6 +96,6 @@ module Padrino
                  "cannot be accessed by the current user!"
           end
         end
-    end
-  end
-end
+    end # Base
+  end # Cli
+end # Padrino

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

@@ -11,7 +11,6 @@ def shell
 end
 
 task :environment do
-  Padrino.logger_env = :test
   Padrino.mounted_apps.each do |app|
     Padrino.require_dependency(app.app_file)
     app.app_object.setup_application!

data/lib/padrino-core/loader.rb

@@ -1,54 +1,97 @@
 module Padrino
   class << self
+    ##
     # Requires necessary dependencies as well as application files from root lib and models
+    # 
     def load!
       return false if loaded?
       @_called_from = first_caller
-      # load_required_gems # load bundler gems
-      require_dependencies("#{root}/lib/**/*.rb", "#{root}/models/**/*.rb") # load root app models
+      set_encoding
+      set_load_paths(*load_paths) # we set the padrino load paths
+      require_dependencies("#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb") # load root libs
+      require_dependencies("#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb") # load root models
       require_dependencies("#{root}/config/database.rb", "#{root}/config/apps.rb") # load configuration
       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.
+    # 
     def called_from
       @_called_from || first_caller
     end
 
+    ##
     # Return true if Padrino was loaded with Padrino.load!
+    # 
     def loaded?
       Thread.current[:padrino_loaded]
     end
 
+    ##
     # Attempts to require all dependency libs that we need.
     # If you use this method we can perform correctly a Padrino.reload!
-    #
-    # ==== Parameters
-    # paths:: Path where is necessary require a dependency
-    #
+    # Another good thing that this method are dependency check, for example:
+    # 
+    #   models
+    #    \-- a.rb => require something of b.rb
+    #    \-- b.rb
+    # 
+    # In the example above if we do:
+    # 
+    #   Dir["/models/*.rb"].each { |r| require r }
+    # 
+    # we get an error, because we try to require first a.rb that need +something+ of b.rb.
+    # 
+    # With +require_dependencies+ we don't have this problem.
+    # 
     # 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) }
+      # Extract all files to load
+      files = paths.map { |path| Dir[path] }.flatten
+
+      while files.present?
+        # We need a size to make sure things are loading
+        size_at_start = files.size
+
+        # List of errors and failed files
+        errors, failed = [], []
+
+        # Now we try to require our dependencies
+        files.each do |file|
+          begin
+            require file
+            files.delete(file)
+          rescue Exception => e
+            errors << e
+            failed << files
+          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?
       end
     end
     alias :require_dependency :require_dependencies
 
+    ##
     # 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) }
@@ -56,5 +99,12 @@ module Padrino
     end
     alias :load_dependency :load_dependencies
 
-  end
-end
+    ##
+    # Concat to $LOAD_PATH the given paths
+    # 
+    def set_load_paths(*paths)
+      $:.concat(paths)
+      $:.uniq!
+    end
+  end # self
+end # Padrino

data/lib/padrino-core/logger.rb

@@ -1,13 +1,20 @@
+# Defines our PADRINO_LOG_LEVEL
+PADRINO_LOG_LEVEL = ENV['PADRINO_LOG_LEVEL'] unless defined?(PADRINO_LOG_LEVEL)
+
 module Padrino
 
+  ##
+  # Returns the padrino logger
+  # 
+  # Examples:
+  # 
+  #   logger.debug "foo"
+  #   logger.warn "bar"
+  # 
   def self.logger
     Thread.current[:padrino_logger] ||= Padrino::Logger.setup!
   end
 
-  def self.logger_env=(env)
-    Thread.current[:padrino_logger] ||= Padrino::Logger.setup!(env)
-  end
-
   class Logger
 
     attr_accessor :level
@@ -16,7 +23,7 @@ module Padrino
     attr_reader   :log
     attr_reader   :init_args
 
-    # ==== Notes
+    ##
     # Ruby (standard) logger levels:
     # 
     # :fatal:: An unhandleable error that results in a program crash
@@ -34,7 +41,7 @@ module Padrino
 
     @@mutex = {}
 
-    # ==== Notes
+    ##
     # Configuration for a given environment, possible options are:
     # 
     # :log_level:: Once of [:fatal, :error, :warn, :info, :debug]
@@ -61,16 +68,19 @@ module Padrino
     #   :production  => { :log_level => :warn, :stream => :to_file }
     #   :development => { :log_level => :debug, :stream => :stdout }
     #   :test        => { :log_level => :fatal, :stream => :null }
+    # 
     Config = {
-      :production  => { :log_level => :warn, :stream => :to_file },
+      :production  => { :log_level => :warn,  :stream => :to_file },
       :development => { :log_level => :debug, :stream => :stdout },
       :test        => { :log_level => :debug, :stream => :null }
     } unless const_defined?(:Config)
 
-
+    ##
     # Setup a new logger
-    def self.setup!(env=nil)
-      config = Config[env || Padrino.env] || Config[:test]
+    # 
+    def self.setup!
+      config_level = (PADRINO_LOG_LEVEL || Padrino.env || :test).to_sym # need this for PADRINO_LOG_LEVEL
+      config = Config[config_level]
       stream = case config[:stream]
         when :to_file
           FileUtils.mkdir_p(Padrino.root("log")) unless File.exists?(Padrino.root("log"))
@@ -85,6 +95,7 @@ module Padrino
 
     public
 
+    ##
     # To initialize the logger you create a new object, proxies to set_log.
     #
     # ==== Options can be:
@@ -109,7 +120,9 @@ module Padrino
       @format_message    = options[:format_message] || "%-5s - [%s] \"%s\""
     end
 
+    ##
     # Flush the entire buffer to the log object.
+    # 
     def flush
       return unless @buffer.size > 0
       @mutex.synchronize do
@@ -117,21 +130,19 @@ module Padrino
       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
@@ -143,7 +154,9 @@ module Padrino
       message
     end
 
+    ##
     # Generate the logging methods for Padrino.logger for each log level.
+    # 
     Levels.each_pair do |name, number|
       class_eval <<-LEVELMETHODS, __FILE__, __LINE__
 
@@ -191,13 +204,17 @@ module Padrino
 
   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)
@@ -237,13 +254,15 @@ module Padrino
       end
       '-'
     end
-  end
-end
+  end # Logger
+end # Padrino
 
 module Kernel
 
+  ##
   # Define a logger available every where in our app
+  # 
   def logger
     Padrino.logger
   end
-end
+end # Kernel

data/lib/padrino-core/mounter.rb

@@ -1,8 +1,13 @@
 module Padrino
+  ##
   # Represents a particular mounted padrino application
   # Stores the name of the application (app folder name) and url mount path
-  # @example Mounter.new("blog_app", :app_class => "Blog").to("/blog")
-  # @example Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
+  # 
+  # Example:
+  # 
+  #   Mounter.new("blog_app", :app_class => "Blog").to("/blog")
+  #   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, :app_obj
 
@@ -14,17 +19,24 @@ module Padrino
       @app_obj   = self.app_object
     end
 
+    ##
     # Registers the mounted application onto Padrino
-    # @example Mounter.new("blog_app").to("/blog")
+    # 
+    # Example:
+    #   Mounter.new("blog_app").to("/blog")
+    # 
     def to(mount_url)
       @uri_root  = mount_url
       Padrino.insert_mounted_app(self)
       self
     end
 
+    ##
     # Maps Padrino application onto a Rack::Builder
     # For use in constructing a Rack application
-    # @example @app.map_onto(@builder)
+    # 
+    #   @app.map_onto(@builder)
+    # 
     def map_onto(builder)
       app_data, app_obj = self, @app_obj
       builder.map self.uri_root do
@@ -38,19 +50,25 @@ module Padrino
       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
@@ -59,25 +77,36 @@ module Padrino
   class << self
     attr_writer :mounted_root # Set root directory where padrino searches mounted apps
 
+    ##
     # Returns the root to the mounted apps base directory
+    # 
     def mounted_root(*args)
       Padrino.root(@mounted_root ||= "", *args)
     end
 
+    ##
     # Returns the mounted padrino applications (MountedApp objects)
+    # 
     def mounted_apps
       @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")
+    # 
+    # Examples:
+    # 
+    #   Padrino.mount_core("Blog")
+    #   Padrino.mount_core(:app_file => "/path/to/file", :app_class => "Blog")
+    # 
     def mount_core(*args)
       options = args.extract_options!
       app_class = args.size > 0 ? args.first.to_s.camelize : nil
@@ -85,10 +114,13 @@ module Padrino
       mount("core", options).to("/")
     end
 
+    ##
     # Mounts a new sub-application onto Padrino project
-    # @example Padrino.mount("blog_app").to("/blog")
+    # 
+    #   Padrino.mount("blog_app").to("/blog")
+    # 
     def mount(name, options={})
       Mounter.new(name, options)
     end
-  end
-end
+  end # Mounter
+end # Padrino