padrino-core 0.9.10 → 0.9.11

data/README.rdoc

@@ -150,7 +150,7 @@ and even configure the respond_to for each route:
 
   # app/controllers/example.rb
   SimpleApp.controllers :admin do
-    get :show, :with => :id, :respond_to => :js do
+    get :show, :with => :id, :provides => :js do
       "Url is /admin/show/#{params[:id]}.#{params[:format]}"
     end
 
@@ -166,7 +166,7 @@ or auto lookup for current locale or content_type
 
   # app/controllers/example.rb
   SimpleApp.controllers :admin do
-    get :show, :with => :id, :respond_to => [html, :js] do
+    get :show, :with => :id, :provides => [html, :js] do
       render "admin/show"
     end
   end

data/Rakefile

@@ -1,57 +1,5 @@
-require 'rubygems'
-require 'rake'
-require File.expand_path("../lib/padrino-core/version.rb", __FILE__)
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "padrino-core"
-    gem.summary = "The required Padrino core gem"
-    gem.description = "The Padrino core gem required for use of this framework"
-    gem.email = "padrinorb@gmail.com"
-    gem.homepage = "http://github.com/padrino/padrino-framework/tree/master/padrino-core"
-    gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-    gem.executables = ["padrino"]
-    gem.rubyforge_project = 'padrino-core'
-    gem.version = Padrino.version
-    gem.add_runtime_dependency     "sinatra",       ">= 1.0.0"
-    gem.add_runtime_dependency     "i18n",          ">= 0.3.2"
-    gem.add_runtime_dependency     "usher",         ">= 0.6.2"
-    gem.add_runtime_dependency     "thor",          ">= 0.13.0"
-    gem.add_runtime_dependency     "bundler",       ">= 0.9.7"
-    gem.add_runtime_dependency     "activesupport", "= 2.3.5"
-    gem.add_development_dependency "shoulda",       ">= 2.10.3"
-    gem.add_development_dependency "mocha",         ">= 0.9.7"
-    gem.add_development_dependency "rack-test",     ">= 0.5.0"
-    gem.add_development_dependency "webrat",        ">= 0.5.1"
-    gem.add_development_dependency "haml",          ">= 2.2.22"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new { |r| r.doc_task = :none }
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
+# coding:utf-8
+RAKE_ROOT = __FILE__
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |rcov|
-    rcov.libs << 'test'
-    rcov.pattern = 'test/**/test_*.rb'
-    rcov.verbose = true
-    rcov.rcov_opts << ['--exclude /Gems/1.8/gems/,padrino-admin,padrino-cache,padrino-gen,padrino-helpers,padrino-mailer']
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install relevance-rcov"
-  end
-end
-
-task :default => :test
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/bin/padrino

@@ -1,27 +1,24 @@
 #!/usr/bin/env ruby
-require 'rubygems'
 
+# We load Padrino libs
 padrino_core_path = File.expand_path('../../lib', __FILE__)
 $:.unshift(padrino_core_path) if File.directory?(padrino_core_path) && !$:.include?(padrino_core_path)
 
-padrino_local_path = Dir.pwd
-$:.unshift(padrino_local_path) if File.directory?(padrino_local_path) && !$:.include?(padrino_local_path)
-
-require 'padrino-core/cli/base'
-require 'padrino-core/support_lite'
-
+# Build Padrino g as an alias of padrino-gen
 if %w(g gen).include?(ARGV[0])
   ARGV.shift
   begin
     # We try to load the vendored padrino-gen if exist
     padrino_gen_path = File.expand_path('../../../padrino-gen/lib', __FILE__)
     $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include?(padrino_gen_path)
-    require 'padrino-gen'
+    require 'padrino-core/command'
+    require 'padrino-gen/command'
     Padrino.bin_gen(ARGV)
   rescue
     puts "<= You need padrino-gen! Run: gem install padrino-gen"
   end
-  exit(0)
-end
-
-Padrino::Cli::Base.start(ARGV)
+else
+  # We load our cli
+  require 'padrino-core/cli/base'
+  Padrino::Cli::Base.start(ARGV)
+end

data/lib/padrino-core.rb

@@ -1,11 +1,12 @@
 require 'sinatra/base'
-require 'padrino-core/support_lite'
+require 'padrino-core/support_lite' unless defined?(SupportLite)
 
-Dir[File.dirname(__FILE__) + '/padrino-core/application/*.rb'].each {|file| require file }
-Dir[File.dirname(__FILE__) + '/padrino-core/*.rb'].each {|file| require file }
+FileSet.glob_require('padrino-core/application/*.rb', __FILE__)
+FileSet.glob_require('padrino-core/*.rb', __FILE__)
 
-# Defines our PADRINO_ENV
-PADRINO_ENV = ENV["PADRINO_ENV"] ||= ENV["RACK_ENV"] ||= "development" unless defined?(PADRINO_ENV)
+# Defines our Constants
+PADRINO_ENV  = ENV["PADRINO_ENV"]  ||= ENV["RACK_ENV"] ||= "development"  unless defined?(PADRINO_ENV)
+PADRINO_ROOT = ENV["PADRINO_ROOT"] ||= File.dirname(Padrino.first_caller) unless defined?(PADRINO_ROOT)
 
 module Padrino
   class ApplicationLoadError < RuntimeError #:nodoc:
@@ -36,7 +37,7 @@ module Padrino
     # 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?
+      raise ApplicationLoadError, "At least one app must be mounted!" unless self.mounted_apps && self.mounted_apps.any?
       router = Padrino::Router.new
       self.mounted_apps.each { |app| app.map_onto(router) }
       router

data/lib/padrino-core/application.rb

@@ -43,9 +43,16 @@ module Padrino
       #   MyApp.reload!
       #
       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
+        reset! # Reset sinatra app
+        reset_routes! # Remove all existing user-defined application routes
+        Padrino.require_dependencies(File.join(self.root, "/models.rb")) # Reload models class
+        Padrino.require_dependencies(File.join(self.root, "/models/**/*.rb")) # Reload all models
+        Padrino.require_dependencies(self.app_file) # Reload the app file
+        register_initializers # Reload our middlewares
+        require_load_paths # Reload dependencies
+        default_filters! # Reload filters
+        default_errors!  # Reload our errors
+        I18n.reload! if defined?(I18n) # Reload also our translations
       end
 
       ##
@@ -60,6 +67,13 @@ module Padrino
         default_routes!
       end
 
+      ##
+      # Returns the routes of our app
+      #
+      def routes
+        router.routes
+      end
+
       ##
       # Setup the application by registering initializers, load paths and logger
       # Invoked automatically when an application is first instantiated
@@ -67,25 +81,48 @@ module Padrino
       def setup_application!
         return if @_configured
         self.calculate_paths
-        self.register_framework_extensions
         self.register_initializers
         self.require_load_paths
         self.disable :logging # We need do that as default because Sinatra use commonlogger.
         self.default_filters!
         self.default_routes!
         self.default_errors!
-        I18n.load_path += self.locale_path
-        I18n.reload!
+        if defined?(I18n)
+          I18n.load_path += self.locale_path
+          I18n.reload!
+        end
         @_configured = true
       end
 
+      ##
+      # Run the Padrino app as a self-hosted server using
+      # Thin, Mongrel or WEBrick (in that order)
+      #
+      def run!(options={})
+        return unless Padrino.load!
+        set options
+        handler      = detect_rack_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        puts "=> #{self.name}/#{Padrino.version} has taken the stage #{Padrino.env} on #{port}" unless handler_name =~/cgi/i
+        handler.run self, :Host => bind, :Port => port do |server|
+          trap(:INT) do
+            ## Use thins' hard #stop! if available, otherwise just #stop
+            server.respond_to?(:stop!) ? server.stop! : server.stop
+            puts "<= #{self.name} has ended his set (crowd applauds)" unless handler_name =~/cgi/i
+          end
+          set :running, true
+        end
+      rescue Errno::EADDRINUSE => e
+        puts "<= Someone is already performing on port #{port}!"
+      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 :app_file, File.expand_path(caller_files.first || $0) # Assume app file is first caller
           set :environment, Padrino.env
           set :raise_errors, true if development?
           set :reload, true if development?
@@ -101,9 +138,6 @@ module Padrino
           set :authentication, false
           # Padrino locale
           set :locale_path, Proc.new { Dir[File.join(self.root, "/locale/**/*.{rb,yml}")] }
-          # Plugin specific
-          set :padrino_mailer, defined?(Padrino::Mailer)
-          set :padrino_helpers, defined?(Padrino::Helpers)
         end
 
         ##
@@ -162,15 +196,6 @@ module Padrino
           use Rack::Flash              if flash? && sessions?
         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::Admin::AccessControl if authentication?
-        end
-
         ##
         # Returns the load_paths for the application (relative to the application root)
         #

data/lib/padrino-core/application/mounter.rb

@@ -9,12 +9,16 @@ module Padrino
   #   Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
   #
   class Mounter
+    class MounterException < RuntimeError #:nodoc:
+    end
+
     attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host
 
     def initialize(name, options={})
       @name      = name.underscore
       @app_class = options[:app_class] || name.classify
       @app_file  = options[:app_file]  || locate_app_file
+      raise MounterException, "Unable to locate app file for #{name}, try with :app_file => /path" unless @app_file
       @app_root  = options[:app_root]  || File.dirname(@app_file)
       @app_obj   = self.app_object
       @uri_root  = "/"
@@ -70,16 +74,26 @@ module Padrino
     # Return the class for the app
     #
     def app_object
-      app_class.constantize rescue Padrino.require_dependency(app_file)
-      app_class.constantize
+      begin
+        app_class.constantize
+      rescue
+        if app_file
+          Padrino.require_dependencies(app_file)
+          app_class.constantize
+        end
+      end
     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")
+      candidates  = []
+      candidates << app_object.app_file  if app_object.respond_to?(:app_file) && File.exist?(app_object.app_file)
+      candidates << Padrino.first_caller if File.identical?(Padrino.first_caller.to_s, Padrino.called_from.to_s)
+      candidates << Padrino.mounted_root(name, "app.rb")
+      candidates << Padrino.root("app", "app.rb")
+      candidates.find { |candidate| File.exist?(candidate) }
     end
 
     ##
@@ -126,7 +140,7 @@ module Padrino
     def mount_core(*args)
       options = args.extract_options!
       app_class = args.size > 0 ? args.first.to_s.camelize : nil
-      options.reverse_merge!(:app_class => app_class, :app_file => Padrino.root("app", "app.rb"))
+      options.reverse_merge!(:app_class => app_class)
       mount("core", options).to("/")
     end
 

data/lib/padrino-core/application/rendering.rb

@@ -1,3 +1,5 @@
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+
 module Padrino
   ##
   # Padrino enhances the Sinatra ‘render’ method to have support for automatic template engine detection,
@@ -17,12 +19,20 @@ module Padrino
       /~$/ # This is for Gedit
     ]
 
-    def self.registered(app)
-      app.send(:include, Padrino::Rendering)
-    end
+    ##
+    # Default rendering options used in the #render-method
+    #
+    DEFAULT_RENDERING_OPTIONS = { :strict_format => false, :raise_exceptions => true }
 
-    def self.included(base)
-      base.extend(ClassMethods)
+    ##
+    # Main class that register this extension
+    #
+    class << self
+      def registered(app)
+        app.send(:include, InstanceMethods)
+        app.extend(ClassMethods)
+      end
+      alias :included :registered
     end
 
     module ClassMethods
@@ -58,6 +68,9 @@ module Padrino
         (@_cached_templates ||= {})[render_options] = template_file || []
       end
 
+      ##
+      # Retunrs the cached layout path.
+      #
       def fetch_layout_path
         layout_name = @layout || :application
         @_cached_layout ||= {}
@@ -70,107 +83,116 @@ module Padrino
       end
     end
 
-    private
-      ##
-      # Enhancing Sinatra render functionality for:
-      #
-      # * Using layout similar to rails
-      # * Use render 'path/to/my/template'   (without symbols)
-      # * Use render 'path/to/my/template'   (with engine lookup)
-      # * Use render 'path/to/template.haml' (with explicit engine lookup)
-      # * Use render 'path/to/template', :layout => false
-      # * Use render 'path/to/template', :layout => false, :engine => 'haml'
-      # * Use render { :a => 1, :b => 2, :c => 3 } # => return a json string
-      #
-      def render(engine, data=nil, options={}, locals={}, &block)
-        # If engine is a hash then render data converted to json
-        return engine.to_json if engine.is_a?(Hash)
-
-        # Data can actually be a hash of options in certain cases
-        options.merge!(data) && data = nil if data.is_a?(Hash)
-
-        # If an engine is a string then this is a likely a path to be resolved
-        data, engine = *resolve_template(engine, options) if data.nil?
-
-        # Sinatra 1.0 requires an outvar for erb and erubis templates
-        options[:outvar] ||= '@_out_buf' if [:erb, :erubis] & [engine]
-
-        # Resolve layouts similar to in Rails
-        if (options[:layout].nil? || options[:layout] == true) && !self.class.templates.has_key?(:layout)
-          options[:layout] = resolved_layout || false # We need to force layout false so sinatra don't try to render it
-          logger.debug "Resolving layout #{options[:layout]}" if defined?(logger) && options[:layout].present?
-        end
-
-        # Pass arguments to Sinatra render method
-        super(engine, data, options.dup, locals, &block)
+    module InstanceMethods
+      def content_type(type=nil, params={}) #:nodoc:
+        type.nil? ? @_content_type : super(type, params)
       end
 
-      ##
-      # Returns the located layout to be used for the rendered template (if available)
-      #
-      # ==== Example
-      #
-      # resolve_layout(true)
-      # => "/layouts/custom"
-      #
-      def resolved_layout
-        located_layout = resolve_template(self.class.fetch_layout_path, :strict_format => true, :raise_exceptions => false)
-        located_layout ? located_layout[0] : false
-      end
+      private
+        ##
+        # Enhancing Sinatra render functionality for:
+        #
+        # * Using layout similar to rails
+        # * Use render 'path/to/my/template'   (without symbols)
+        # * Use render 'path/to/my/template'   (with engine lookup)
+        # * Use render 'path/to/template.haml' (with explicit engine lookup)
+        # * Use render 'path/to/template', :layout => false
+        # * Use render 'path/to/template', :layout => false, :engine => 'haml'
+        # * Use render { :a => 1, :b => 2, :c => 3 } # => return a json string
+        #
+        def render(engine, data=nil, options={}, locals={}, &block)
+          # If engine is a hash then render data converted to json
+          return engine.to_json if engine.is_a?(Hash)
+
+          # Data can actually be a hash of options in certain cases
+          options.merge!(data) && data = nil if data.is_a?(Hash)
+
+          # If an engine is a string then this is a likely a path to be resolved
+          data, engine = *resolve_template(engine, options) if data.nil?
+
+          # Sinatra 1.0 requires an outvar for erb and erubis templates
+          options[:outvar] ||= '@_out_buf' if [:erb, :erubis] & [engine]
+
+          # Resolve layouts similar to in Rails
+          if (options[:layout].nil? || options[:layout] == true) && !settings.templates.has_key?(:layout)
+            options[:layout] = resolved_layout || false # We need to force layout false so sinatra don't try to render it
+            logger.debug "Resolving layout #{options[:layout]}" if defined?(logger) && options[:layout].present?
+          end
+
+          # Pass arguments to Sinatra render method
+          super(engine, data, options.dup, locals, &block)
+        end
 
-      ##
-      # Returns the template path and engine that match content_type (if present), I18n.locale.
-      #
-      # === Options
-      #
-      #   :strict_format::  The resolved template must match the content_type of the request (defaults to false)
-      #   :raise_exceptions::  Raises a +TemplateNotFound+ exception if the template cannot be located.
-      #
-      # ==== Example
-      #
-      #   get "/foo", :respond_to => [:html, :js] do; render 'path/to/foo'; end
-      #   # If you request "/foo.js" with I18n.locale == :ru => [:"/path/to/foo.ru.js", :erb]
-      #   # If you request "/foo" with I18n.locale == :de => [:"/path/to/foo.de.haml", :haml]
-      #
-      def resolve_template(template_path, options={})
-        # Fetch cached template for rendering options
-        template_path = "/#{template_path}" unless template_path.to_s[0] == ?/
-        rendering_options = [template_path, content_type, locale]
-        cached_template = self.class.fetch_template_file(rendering_options)
-        return cached_template if cached_template
-
-        # Resolve view path and options
-        options.reverse_merge!(:strict_format => false, :raise_exceptions => true)
-        view_path = options.delete(:views) || self.options.views || self.class.views || "./views"
-        target_extension = File.extname(template_path)[1..-1] || "none" # retrieves explicit template extension
-        template_path = template_path.chomp(".#{target_extension}")
-
-        # Generate potential template candidates
-        templates = Dir[File.join(view_path, template_path) + ".*"].map do |file|
-          template_engine = File.extname(file)[1..-1].to_sym # retrieves engine extension
-          template_file   = file.sub(view_path, '').chomp(".#{template_engine}").to_sym # retrieves template filename
-          [template_file, template_engine] unless IGNORE_FILE_PATTERN.any? { |pattern| template_engine.to_s =~ pattern }
+        ##
+        # Returns the located layout to be used for the rendered template (if available)
+        #
+        # ==== Example
+        #
+        # resolve_layout(true)
+        # => "/layouts/custom"
+        #
+        def resolved_layout
+          located_layout = resolve_template(settings.fetch_layout_path, :strict_format => true, :raise_exceptions => false)
+          located_layout ? located_layout[0] : false
         end
 
-        # Resolve final template to render
-        located_template =
-          templates.find { |file, e| file.to_s == "#{template_path}.#{locale}.#{content_type}" } ||
-          templates.find { |file, e| file.to_s == "#{template_path}.#{locale}" && content_type == :html } ||
-          templates.find { |file, e| File.extname(file.to_s) == ".#{target_extension}" or e.to_s == target_extension.to_s } ||
-          templates.find { |file, e| file.to_s == "#{template_path}.#{content_type}" } ||
-          templates.find { |file, e| file.to_s == "#{template_path}" && content_type == :html } ||
-          templates.any? && !options[:strict_format] && templates.first # If not strict, fall back to the first located template
-
-        self.class.cache_template_file!(located_template, rendering_options) unless settings.reload_templates?
-        raise TemplateNotFound.new("Template path '#{template_path}' could not be located!") if !located_template && options[:raise_exceptions]
-        located_template
-      end
+        ##
+        # Returns the template path and engine that match content_type (if present), I18n.locale.
+        #
+        # === Options
+        #
+        #   :strict_format::  The resolved template must match the content_type of the request (defaults to false)
+        #   :raise_exceptions::  Raises a +TemplateNotFound+ exception if the template cannot be located.
+        #
+        # ==== Example
+        #
+        #   get "/foo", :provides => [:html, :js] do; render 'path/to/foo'; end
+        #   # If you request "/foo.js" with I18n.locale == :ru => [:"/path/to/foo.ru.js", :erb]
+        #   # If you request "/foo" with I18n.locale == :de => [:"/path/to/foo.de.haml", :haml]
+        #
+        def resolve_template(template_path, options={})
+          # Fetch cached template for rendering options
+          template_path = "/#{template_path}" unless template_path.to_s[0] == ?/
+          rendering_options = [template_path, content_type, locale]
+          cached_template = settings.fetch_template_file(rendering_options)
+          return cached_template if cached_template
+
+          # Resolve view path and options
+          options.reverse_merge!(DEFAULT_RENDERING_OPTIONS)
+          view_path = options.delete(:views) || settings.views || settings.views || "./views"
+          target_extension = File.extname(template_path)[1..-1] || "none" # retrieves explicit template extension
+          template_path = template_path.chomp(".#{target_extension}")
+
+          # Generate potential template candidates
+          templates = Dir[File.join(view_path, template_path) + ".*"].map do |file|
+            template_engine = File.extname(file)[1..-1].to_sym # retrieves engine extension
+            template_file   = file.sub(view_path, '').chomp(".#{template_engine}").to_sym # retrieves template filename
+            [template_file, template_engine] unless IGNORE_FILE_PATTERN.any? { |pattern| template_engine.to_s =~ pattern }
+          end
+
+          # Check if we have a valid content type
+          valid_content_type = [:html, :plain].include?(content_type)
+
+          # Resolve final template to render
+          located_template =
+            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}.#{content_type}" } ||
+            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}" && valid_content_type } ||
+            templates.find { |file, e| File.extname(file.to_s) == ".#{target_extension}" or e.to_s == target_extension.to_s } ||
+            templates.find { |file, e| file.to_s == "#{template_path}.#{content_type}" } ||
+            templates.find { |file, e| file.to_s == "#{template_path}" && valid_content_type } ||
+            templates.any? && !options[:strict_format] && templates.first # If not strict, fall back to the first located template
+
+          settings.cache_template_file!(located_template, rendering_options) unless settings.reload_templates?
+          raise TemplateNotFound, "Template path '#{template_path}' could not be located in '#{view_path}'!" if !located_template && options[:raise_exceptions]
+          located_template
+        end
 
-      ##
-      # Return the I18n.locale if I18n is defined
-      #
-      def locale
-        I18n.locale if defined?(I18n)
-      end
+        ##
+        # Return the I18n.locale if I18n is defined
+        #
+        def locale
+          I18n.locale if defined?(I18n)
+        end
+    end # InstanceMethods
   end # Rendering
 end # Padrino