padrino-core 0.6.3 → 0.6.7

data/VERSION

@@ -1 +1 @@
-0.6.3
+0.6.7

data/bin/padrino

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 %w[rubygems thor].each { |gem| require gem }
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+$:.unshift File.dirname(__FILE__) + "/../lib"
 
 require "padrino-core/cli"
 arguments = ARGV.any? ? ARGV : ['-h']

data/lib/padrino-core.rb

@@ -6,49 +6,83 @@ PADRINO_ENV = ENV["PADRINO_ENV"] ||= ENV["RACK_ENV"] ||= "development" unless de
 
 module Padrino
   class ApplicationLoadError < RuntimeError; end
-  # Helper method for file references.
-  #
-  # Example:
-  #   # Referencing a file in config called settings.yml
-  #   Padrino.root("config", "settings.yml")
-  #   # returns PADRINO_ROOT + "/config/setting.yml"
-  def self.root(*args)
-    File.expand_path(File.join(PADRINO_ROOT, *args))
-  end
-
-  # Helper method that return PADRINO_ENV
-  def self.env
-    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 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
-  end
-
-  # Method used for require dependencies and correct support_lite
-  def self.require_dependencies!
-    require root('vendor', 'gems', 'environment')
-    Bundler.require_env(Padrino.env)
-    Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
-    puts "=> Loaded bundled gems for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
-  rescue LoadError
-    require 'bundler'
-    if File.exist?(root("Gemfile"))
-      Bundler::Bundle.load(root("Gemfile")).environment.require_env(Padrino.env)
-      Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
-      puts "=> Located Gemfile for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
-    else
+
+  class << self
+    ##
+    # Helper method for file references.
+    #
+    # Example:
+    #   # Referencing a file in config called settings.yml
+    #   Padrino.root("config", "settings.yml")
+    #   # returns PADRINO_ROOT + "/config/setting.yml"
+    # 
+    def root(*args)
+      File.expand_path(File.join(PADRINO_ROOT, *args))
+    end
+
+    ##
+    # Helper method that return PADRINO_ENV
+    # 
+    def env
+      PADRINO_ENV.to_s.downcase.to_sym
+    end
+
+    ##
+    # Returns the resulting rack builder mapping each 'mounted' application
+    # 
+    def application
+      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
+    end
+
+    ##
+    # Default encoding to UTF8 if it has not already been set to something else.
+    #
+    def set_encoding
+      unless RUBY_VERSION >= '1.9'
+        $KCODE = 'UTF8' if $KCODE == 'NONE' || $KCODE.blank?
+      end
+      nil
+    end
+
+    ##
+    # Returns the used $LOAD_PATHS from padrino
+    # 
+    def load_paths
+      %w(
+        lib
+        models
+        shared
+      ).map { |dir| root(dir) }
+    end
+
+    ##
+    # Method used for require dependencies and correct support_lite
+    # 
+    def require_dependencies!
+      require root('vendor', 'gems', 'environment')
+      Bundler.require_env(Padrino.env)
       Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
+      puts "=> Loaded bundled gems for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
+    rescue LoadError
+      require 'bundler'
+      if File.exist?(root("Gemfile"))
+        Bundler::Bundle.load(root("Gemfile")).environment.require_env(Padrino.env)
+        Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
+        puts "=> Located Gemfile for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
+      else
+        Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
+      end
     end
-  end
-end
+  end # self
+end # Padrino
 
+##
 # When we require this file is necessary check if we have a gemfile o bundled gems, 
 # this because we load ExtLib or ActiveSupport if some of our dependencies
 # just require them. This prevent for example to load ActiveSupport
 # when we require only 'dm-core'.
+# 
 Padrino.require_dependencies!

data/lib/padrino-core/application.rb

@@ -1,61 +1,34 @@
 module Padrino
   class ApplicationSetupError < RuntimeError; end
+  ##
   # Subclasses of this become independent Padrino applications (stemming from Sinatra::Application)
   # These subclassed applications can be easily mounted into other Padrino applications as well.
+  # 
   class Application < Sinatra::Application
 
-    # Return the request format, this is useful when we need to respond to a given content_type like:
-    # 
-    #   get :index, :respond_to => :any do
-    #     case content_type
-    #       when :js    then ...
-    #       when :json  then ...
-    #       when :html  then ...
-    #     end
-    #   end
-    def content_type(type=nil, params={})
-      type.nil? ? @_content_type : super(type, params)
-    end
-
-    
-    # Instance method for url generation like:
-    # 
-    #   url(:show, :id => 1)
-    #   url(:show, :name => :test)
-    #   url("/show/:id/:name", :id => 1, :name => foo)
-    # 
-    def url(name, *params)
-      self.class.url(name, *params)
-    end
-    alias :url_for :url
-
-    # This is mostly just a helper so request.path_info isn't changed when
-    # serving files from the public directory
-    def static_file?(path)
-      public_dir = File.expand_path(options.public)
-      path = File.expand_path(File.join(public_dir, unescape(path)))
-      path[0, public_dir.length] == public_dir && File.file?(path)
-    end
-
     class << self
       def inherited(subclass)
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
         subclass.default_configuration!
-        Padrino.require_dependencies(File.join(subclass.root, "/models/**/*.rb"))
+        Padrino.set_load_paths File.join(subclass.root, "/models")
+        Padrino.require_dependencies File.join(subclass.root, "/models/**/*.rb")
         super # Loading the subclass
         subclass.default_filters!
         subclass.default_routes!
       end
 
+      ##
       # Hooks into when a new instance of the application is created
       # This is used because putting the configuration into inherited doesn't
       # take into account overwritten app settings inside subclassed definitions
-      # Only performs the setup first time application is initialized
+      # Only performs the setup first time application is initialized.
+      # 
       def new(*args, &bk)
         setup_application!
         super
       end
 
+      ##
       # Method for organize in a better way our routes like:
       # 
       #   controller :admin do
@@ -79,7 +52,7 @@ module Padrino
       # 
       #   # => "/admin"
       #   # => "/admin/show/1"
-      #   
+      # 
       def controller(*extensions, &block)
         if block_given?
           @_controller, original = extensions, @_controller
@@ -91,7 +64,9 @@ module Padrino
       end
       alias :controllers :controller
 
-      # Usher router
+      ##
+      # Usher router, for fatures and configurations see: http://github.com/joshbuddy/usher
+      # 
       def router
         @router ||= Usher.new(:request_methods => [:request_method, :host, :port, :scheme], 
                               :ignore_trailing_delimiters => true,
@@ -100,6 +75,7 @@ module Padrino
       end
       alias :urls :router
 
+      ##
       # Instance method for url generation like:
       # 
       #   url(:show, :id => 1)
@@ -118,6 +94,7 @@ module Padrino
       end
       alias :url_for :url
 
+      ##
       # With this method we can use layout like rails do or if a block given like sinatra
       # By default we look in your/app/views/layouts/application.(haml|erb|etc)
       # 
@@ -126,26 +103,33 @@ module Padrino
       #   layout :custom
       # 
       # Padrino look for your/app/views/layouts/custom.(haml|erb|etc)
+      # 
       def layout(name=:layout, &block)
         return super if block_given?
         @_layout = name
       end
 
+      ##
       # 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)) } # reload dependencies
       end
 
+      ##
       # Resets application routes to only routes not defined by the user
+      # 
       def reset_routes!
         router.reset!
         default_routes!
       end
 
+      ##
       # Setup the application by registering initializers, load paths and logger
       # Invoked automatically when an application is first instantiated
+      # 
       def setup_application!
         return if @_configured
         self.register_framework_extensions
@@ -159,7 +143,9 @@ module Padrino
       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
@@ -183,6 +169,9 @@ module Padrino
           set :padrino_helpers, defined?(Padrino::Helpers)
         end
 
+        ##
+        # We need to add almost __sinatra__ images.
+        # 
         def default_routes!
           # images resources
           get "/__sinatra__/:image.png" do
@@ -191,7 +180,9 @@ module Padrino
           end
         end
 
+        ##
         # This filter it's used for know the format of the request, and automatically set the content type.
+        # 
         def default_filters!
           before do
             unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
@@ -202,49 +193,62 @@ module Padrino
           end
         end
 
+        ##
         # Calculates any required paths after app_file and root have been properly configured
         # Executes as part of the setup_application! method
+        # 
         def calculate_paths
           raise ApplicationSetupError.new("Please define 'app_file' option for #{self.name} app!") unless self.app_file
           set :views, find_view_path if find_view_path
           set :images_path, File.join(self.public, "/images") unless self.respond_to?(:images_path)
         end
 
+        ##
         # Requires the middleware and initializer modules to configure components
+        # 
         def register_initializers
           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
+        # 
         def register_framework_extensions
           register Padrino::Mailer        if padrino_mailer?
           register Padrino::Helpers       if padrino_helpers?
           register Padrino::AccessControl if authentication?
         end
 
+        ##
         # Returns the load_paths for the application (relative to the application root)
+        # 
         def load_paths
           @load_paths ||= ["urls.rb", "config/urls.rb", "mailers/*.rb", "controllers/**/*.rb", "helpers/*.rb"]
         end
 
+        ##
         # Requires all files within the application load paths
+        # 
         def require_load_paths
           load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
         end
 
+        ##
         # Returns the path to the views directory from root by returning the first that is found
+        # 
         def find_view_path
           @view_paths = ["views"].collect { |path| File.join(self.root, path) }
           @view_paths.find { |path| Dir[File.join(path, '/**/*')].any? }
         end
 
+        ##
         # Registers an initializer with the application
         # register_initializer('/path/to/initializer')
+        # 
         def register_initializer(file_path)
           Padrino.require_dependencies(file_path)
           file_class = File.basename(file_path, '.rb').camelize
@@ -255,6 +259,7 @@ module Padrino
         end
 
       private
+        ##
         # Rewrite default because now routes can be:
         # 
         #   get :index                                    # => "/"
@@ -337,8 +342,8 @@ module Padrino
           host_name(options.delete(:host)) if options.key?(:host)
 
           # Sinatra defaults
-          define_method "\#{verb} \#{path}", &block
-          unbound_method = instance_method("\#{verb} \#{path}")
+          define_method "#{verb} #{path}", &block
+          unbound_method = instance_method("#{verb} #{path}")
           block =
             if block.arity != 0
               lambda { unbound_method.bind(self).call(*@block_params) }
@@ -352,24 +357,67 @@ module Padrino
           route.name(name) if name
           route
         end
+    end # self
 
+    ##
+    # Return the request format, this is useful when we need to respond to a given content_type like:
+    # 
+    #   get :index, :respond_to => :any do
+    #     case content_type
+    #       when :js    then ...
+    #       when :json  then ...
+    #       when :html  then ...
+    #     end
+    #   end
+    # 
+    def content_type(type=nil, params={})
+      type.nil? ? @_content_type : super(type, params)
     end
 
-    private
-      # TODO: remove this when sinatra 1.0 will be released
-      # Compatibility with sinatra 0.9.4
-      def static!
-        return if (public_dir = options.public).nil?
-        public_dir = File.expand_path(public_dir)
+    ##
+    # Instance method for url generation like:
+    # 
+    #   url(:show, :id => 1)
+    #   url(:show, :name => :test)
+    #   url("/show/:id/:name", :id => 1, :name => foo)
+    # 
+    def url(name, *params)
+      self.class.url(name, *params)
+    end
+    alias :url_for :url
 
-        path = File.expand_path(public_dir + unescape(request.path_info))
-        return if path[0, public_dir.length] != public_dir
-        return unless File.file?(path)
+    ##
+    # This is mostly just a helper so request.path_info isn't changed when
+    # serving files from the public directory
+    # 
+    def static_file?(path_info)
+      [options.public, Padrino.root("shared/public")].find do |folder|
+        next if folder.nil?
+        public_dir = File.expand_path(folder)
+
+        path = File.expand_path(public_dir + unescape(path_info))
+        next if path[0, public_dir.length] != public_dir
+        next unless File.file?(path)
+        return path
+      end
+    end
 
-        send_file path, :disposition => nil
+    private
+
+      ##
+      # Method for deliver static files, Sinatra 0.10.x or 1.0.x have this method
+      # but for now we use this (because we need a compatibility with 0.9.x) and also
+      # because we just have +static_file?+ method.
+      # 
+      def static!
+        if path = static_file?(request.path_info)
+          send_file(path, :disposition => nil)
+        end
       end
 
+      ##
       # Compatibility with usher
+      # 
       def route!(base=self.class, pass_block=nil)
         # TODO: remove this when sinatra 1.0 will be released
         if Sinatra::VERSION =~ /^0\.9/
@@ -399,10 +447,13 @@ module Padrino
         end
       end
       
-      # When we set :auto_locale, true then:
+      ##
+      # When we set :auto_locale, true then if we use param locale like:
+      # 
+      #   get "/:locale/some/foo" do; ...; end
+      # 
+      # we automatically set the I18n locale to params[:locale]
       # 
-      # * if we pass "/:locale/some/foo" we automatically set teh I18n locale to params[:locale]
-      # * if params[:locale] is empty we use the first HTTP_ACCEPT_LANGUAGE
       def route_eval(&block)
         if options.auto_locale
           if params[:locale]
@@ -412,14 +463,18 @@ module Padrino
         super
       end
 
-      # Hijacking the sinatra render for do two thing:
+      ##
+      # Hijacking the sinatra render for do three thing:
       # 
       # * Use layout like rails do
-      # * Use render 'path/to/my/template'
+      # * Use render 'path/to/my/template' (without symbols)
+      # * Use render 'path/to/my/template' (with auto enegine lookup)
       # 
       def render(engine, data=nil, options={}, locals={}, &block)
         # TODO: remove these @template_cache.respond_to?(:clear) when sinatra 1.0 will be released
         @template_cache.clear if Padrino.env != :production && @template_cache && @template_cache.respond_to?(:clear)
+        # If engine is an hash we convert to json
+        return engine.to_json if engine.is_a?(Hash)
         # If an engine is a string probably is a path so we try to resolve them
         if data.nil?
           data   = engine.to_sym
@@ -436,14 +491,15 @@ module Padrino
         super
       end
 
+      ##
       # Returns the template engine (i.e haml) to use for a given template_path
       # resolve_template_engine('users/new') => :haml
+      # 
       def resolve_template_engine(template_path)
         resolved_template_path = File.join(self.options.views, template_path.to_s + ".*")
         template_file = Dir[resolved_template_path].first
         raise "Template path '#{template_path}' could not be located in views!" unless template_file
         template_engine = File.extname(template_file)[1..-1].to_sym
       end
-  end
-
-end
+  end # Application
+end # Padrino