padrino-core 0.12.0 → 0.12.1

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

@@ -1,5 +1,5 @@
 require 'http_router' unless defined?(HttpRouter)
-require 'padrino-core/support_lite' unless defined?(SupportLite)
+require 'padrino-support'
 
 ##
 # Adds to Sinatra +controller+ informations
@@ -205,17 +205,7 @@ module Padrino
     end
 
     def apply?(request)
-      detect = @args.any? do |arg|
-        case arg
-        when Symbol then request.route_obj && (request.route_obj.name == arg or request.route_obj.name == [@scoped_controller, arg].flatten.join(" ").to_sym)
-        else             arg === request.path_info
-        end
-      end || @options.any? do |name, val|
-        case name
-        when :agent then val === request.user_agent
-        else             val === request.send(name)
-        end
-      end
+      detect = match_with_arguments?(request) || match_with_options?(request)
       detect ^ !@mode
     end
 
@@ -227,6 +217,30 @@ module Padrino
         proc { instance_eval(&filter.block) if filter.apply?(request) }
       end
     end
+
+    private
+
+    def scoped_controller_name
+      @scoped_controller_name ||= Array(@scoped_controller).join("_")
+    end
+
+    def match_with_arguments?(request)
+      route, path = request.route_obj, request.path_info
+      @args.any? do |argument|
+        if argument.instance_of?(Symbol)
+          next unless route
+          name = route.name
+          argument == name || name == [scoped_controller_name, argument].join(" ").to_sym
+        else
+          argument === path
+        end
+      end
+    end
+
+    def match_with_options?(request)
+      user_agent = request.user_agent
+      @options.any?{|name, value| value === (name == :agent ? user_agent : request.send(name)) }
+    end
   end
 
   ##
@@ -371,6 +385,7 @@ module Padrino
           @_map,        original_map        = options.delete(:map),        @_map
           @_conditions, original_conditions = options.delete(:conditions), @_conditions
           @_defaults,   original_defaults   = options,                     @_defaults
+          @_accepts,    original_accepts    = options.delete(:accepts),    @_accepts
 
           # Application defaults.
           @filters,     original_filters    = { :before => @filters[:before].dup, :after => @filters[:after].dup }, @filters
@@ -383,9 +398,9 @@ module Padrino
           @layout         = original_layout
 
           # Controller defaults.
-          @_controller, @_parents,  @_cache = original_controller, original_parent,   original_cache
-          @_defaults,   @_provides, @_map   = original_defaults,   original_provides, original_map
-          @_conditions, @_use_format        = original_conditions, original_use_format
+          @_controller, @_parents,  @_cache     = original_controller, original_parent,   original_cache
+          @_defaults,   @_provides, @_map       = original_defaults,   original_provides, original_map
+          @_conditions, @_use_format, @_accepts = original_conditions, original_use_format, original_accepts
         else
           include(*args) if extensions.any?
         end
@@ -677,10 +692,11 @@ module Padrino
         # Do padrino parsing. We dup options so we can build HEAD request correctly.
         route_options = options.dup
         route_options[:provides] = @_provides if @_provides
+        route_options[:accepts]  = @_accepts if @_accepts
 
-        # CSRF protection is always active except when explicitly switched off.
-        if allow_disabled_csrf
-          unless route_options[:csrf_protection] == false
+        # Add Sinatra condition to check rack-protection failure.
+        if protect_from_csrf && (report_csrf_failure || allow_disabled_csrf)
+          unless route_options.has_key?(:csrf_protection)
             route_options[:csrf_protection] = true
           end
         end
@@ -734,7 +750,7 @@ module Padrino
         route.after_filters << @filters[:after]
         if @_controller
           route.use_layout = @layout
-          route.controller = Array(@_controller)[0].to_s
+          route.controller = Array(@_controller).join('/')
         end
 
         deferred_routes[priority] << [route, block]
@@ -772,6 +788,8 @@ module Padrino
 
           # Now we need to parse our provides
           options.delete(:provides) if options[:provides].nil?
+        
+          options.delete(:accepts) if options[:accepts].nil?
 
           if @_use_format or format_params = options[:provides]
             process_path_for_provides(path, format_params)
@@ -932,17 +950,40 @@ module Padrino
       end
 
       ##
-      # Implements CSRF checking when `allow_disabled_csrf` is set to true.
+      # Allows routing by Media type.
+      #
+      # @example
+      #   get "/a", :accepts => [:html, :js]
+      #   # => GET /a CONTENT_TYPE text/html => :html
+      #   # => GET /a CONTENT_TYPE application/javascript => :js
+      #   # => GET /a CONTENT_TYPE application/xml => 406
       #
-      # This condition is always on, except when it is explicitly switched
-      # off.
+      def accepts(*types)
+        mime_types = types.map { |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }.compact
+        condition do
+          halt 406 unless media_type = mime_types.detect{|mime_type| mime_type == request.media_type }
+          if media_type != 'application/json'
+            content_type(media_type, :charset => 'utf-8')
+          else
+            content_type(media_type)
+          end
+        end
+      end
+
+      ##
+      # Implements checking for rack-protection failure flag when
+      # `report_csrf_failure` is enabled.
       #
       # @example
       #   post("/", :csrf_protection => false)
       #
-      def csrf_protection(on = true)
-        if on
-          condition { halt 403 if request.env['protection.csrf.failed'] }
+      def csrf_protection(enabled)
+        return unless enabled
+        condition do
+          if request.env['protection.csrf.failed']
+            message = settings.protect_from_csrf.kind_of?(Hash) && settings.protect_from_csrf[:message] || 'Forbidden'
+            halt(403, message)
+          end
         end
       end
     end

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

@@ -13,15 +13,15 @@ module Padrino
       desc "start", "Starts the Padrino application (alternatively use 's')."
       map "s" => :start
       method_option :server,    :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
-      method_option :host,      :type => :string,  :aliases => "-h", :required => true, :default => '127.0.0.1', :desc => "Bind to HOST address."
-      method_option :port,      :type => :numeric, :aliases => "-p", :required => true, :default => 3000, :desc => "Use PORT."
+      method_option :host,      :type => :string,  :aliases => "-h", :desc => "Bind to HOST address (default: 127.0.0.1)"
+      method_option :port,      :type => :numeric, :aliases => "-p", :desc => "Use PORT (default: 3000)"
       method_option :daemonize, :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background."
       method_option :pid,       :type => :string,  :aliases => "-i", :desc => "File to store pid."
       method_option :debug,     :type => :boolean,                   :desc => "Set debugging flags."
       method_option :options,   :type => :array,  :aliases => "-O", :desc => "--options NAME=VALUE NAME2=VALUE2'. pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} --server_options"
       method_option :server_options,   :type => :boolean, :desc => "Tells the current server handler's options that can be used with --options"
 
-      def start
+      def start(*args)
         prepare :start
         require File.expand_path("../adapter", __FILE__)
         require File.expand_path('config/boot.rb')
@@ -29,7 +29,7 @@ module Padrino
         if options[:server_options]
           puts server_options(options)
         else
-          Padrino::Cli::Adapter.start(options)
+          Padrino::Cli::Adapter.start(args.last ? options.merge(:config => args.last).freeze : options)
         end
       end
 
@@ -69,7 +69,10 @@ module Padrino
         require File.expand_path("../../version", __FILE__)
         ARGV.clear
         require 'irb'
-        require "irb/completion"
+        begin
+          require "irb/completion"
+        rescue LoadError
+        end
         require File.expand_path('config/boot.rb')
         puts "=> Loading #{Padrino.env} console (Padrino v.#{Padrino.version})"
         require File.expand_path('../console', __FILE__)

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

@@ -3,7 +3,10 @@ require 'rake'
 require 'rake/dsl_definition'
 require 'thor'
 require 'securerandom' unless defined?(SecureRandom)
-require 'padrino-gen'
+begin
+  require 'padrino-gen'
+rescue LoadError
+end
 
 module PadrinoTasks
   def self.init(init=false)
@@ -23,18 +26,18 @@ module PadrinoTasks
 
   def self.load?(task, constant_present)
     if constant_present && !PadrinoTasks.tasks.include?(task)
-      warn <<-WARNING.undent
-        Loading #{task} tasks automatically.
-        This functionality will be disabled in future versions. Please put
+      warn <<-WARNING
+Loading #{task} tasks automatically.
+This functionality will be disabled in future versions. Please put
 
-          PadrinoTasks.use(#{task.inspect})
-          PadrinoTasks.init
+  PadrinoTasks.use(#{task.inspect})
+  PadrinoTasks.init
 
-        and remove
+and remove
 
-          require File.expand_path('../config/boot.rb', __FILE__)
+  require File.expand_path('../config/boot.rb', __FILE__)
 
-        in you Rakefile instead.
+in you Rakefile instead.
       WARNING
     end
 

data/lib/padrino-core/loader.rb

@@ -155,7 +155,7 @@ module Padrino
 
         if fatal || !loaded
           e = fatal || error
-          logger.error "#{e.class}: #{e.message}; #{e.backtrace.first}"
+          logger.exception e, :short
           raise e
         end
       end

data/lib/padrino-core/logger.rb

@@ -172,6 +172,31 @@ module Padrino
       def colorize!
         self.extend(Colorize)
       end
+
+      ##
+      # Logs an exception.
+      #
+      # @param [Exception] exception
+      #   The exception to log
+      #
+      # @param [Symbol] verbosity
+      #   :short or :long, default is :long
+      #
+      # @example
+      #   Padrino.logger.exception e
+      #   Padrino.logger.exception(e, :short)
+      def exception(boom, verbosity = :long, level = :error)
+        return unless Levels.has_key?(level)
+        text = ["#{boom.class} - #{boom.message}:"]
+        trace = boom.backtrace
+        case verbosity
+        when :long
+          text += trace
+        when :short
+          text << trace.first
+        end if trace.kind_of?(Array)
+        send level, text.join("\n ")
+      end
     end
 
     module Colorize

data/lib/padrino-core/mounter.rb

@@ -110,8 +110,13 @@ module Padrino
     def named_routes
       app_obj.routes.map { |route|
         route_name = route.name.to_s
-        route_name.sub!(/^#{route.controller} /, "") if route.controller
-        name_array = "(#{route.controller ? %Q[:#{route.controller}] + ", " : ""}:#{route_name})"
+        route_name = 
+          if route.controller
+            route_name.split(" ", 2).map{|name| ":#{name}" }.join(", ")
+          else
+            ":#{route_name}"
+          end
+        name_array = "(#{route_name})"
         request_method = route.request_methods.first
         next if route.name.blank? || request_method == 'HEAD'
         original_path = route.original_path.is_a?(Regexp) ? route.original_path.inspect : route.original_path
@@ -137,7 +142,7 @@ module Padrino
       klass = Object
       for piece in app_class.split("::")
         piece = piece.to_sym
-        if klass.const_defined?(piece)
+        if klass.const_defined?(piece, false)
           klass = klass.const_get(piece)
         else
           return

data/lib/padrino-core/reloader.rb

@@ -96,7 +96,7 @@ module Padrino
         update_modification_time(file)
       rescue Exception => e
         unless options[:cyclic]
-          logger.error "#{e.class}: #{e.message}; #{e.backtrace.first}"
+          logger.exception e, :short
           logger.error "Failed to load #{file}; removing partially defined constants"
         end
         Storage.rollback(file)
@@ -167,10 +167,10 @@ module Padrino
         apps.each { |app| app.app_obj.reload! }
         update_modification_time(file)
       else
-        safe_load(file)
         reloadable_apps.each do |app|
           app.app_obj.reload! if app.app_obj.dependencies.include?(file)
         end
+        safe_load(file)
       end
     end
 

data/lib/padrino-core/server.rb

@@ -9,33 +9,41 @@ module Padrino
   #
   def self.run!(options={})
     Padrino.load!
-    Server.start(Padrino.application, options)
+    Server.start(*detect_application(options))
+  end
+
+  private
+
+  #
+  #
+  def self.detect_application(options)
+    default_config_file = 'config.ru'
+    if (config_file = options.delete(:config)) || File.file?(default_config_file)
+      config_file ||= default_config_file
+      fail "Rack config file `#{config_file}` must have `.ru` extension" unless config_file =~ /\.ru$/
+      rack_app, rack_options = Rack::Builder.parse_file(config_file)
+      [rack_app, rack_options.merge(options)]
+    else
+      [Padrino.application, options]
+    end
   end
 
   ##
   # This module builds a Padrino server to run the project based on available handlers.
   #
   class Server < Rack::Server
+    DEFAULT_ADDRESS = { :Host => '127.0.0.1', :Port => 3000 }
+
     # Server Handlers
-    Handlers = [:thin, :puma, :mongrel, :trinidad, :webrick]
+    Handlers = [:thin, :puma, :'spider-gazelle', :mongrel, :trinidad, :webrick]
 
     # Starts the application on the available server with specified options.
-    def self.start(app, opts={})
-      options = {}.merge(opts) # We use a standard hash instead of Thor::CoreExt::HashWithIndifferentAccess
-      options.symbolize_keys!
-      options[:Host] = options.delete(:host) || '127.0.0.1'
-      options[:Port] = options.delete(:port) || 3000
-      options[:AccessLog] = []
-      if options[:daemonize]
-        options[:pid] = File.expand_path(options[:pid].blank? ? 'tmp/pids/server.pid' : opts[:pid])
-        FileUtils.mkdir_p(File.dirname(options[:pid]))
-      end
+    def self.start(app, options={})
+      options = options.to_hash.symbolize_keys
+      options.update(parse_server_options(options.delete(:options)))
+      options.update(detect_address(options))
+      options[:pid] = prepare_pid(options[:pid]) if options[:daemonize]
       options[:server] = detect_rack_handler if options[:server].blank?
-      if options[:options].is_a?(Array)
-        parsed_server_options = options.delete(:options).map { |opt| opt.split('=', 2) }.flatten
-        server_options = Hash[*parsed_server_options].symbolize_keys!
-        options.merge!(server_options)
-      end
       new(options, app).start
     end
 
@@ -63,6 +71,7 @@ module Padrino
     end
 
     private
+
     # Detects the supported handler to use.
     #
     # @example
@@ -78,5 +87,29 @@ module Padrino
       end
       fail "Server handler (#{Handlers.join(', ')}) not found."
     end
+
+    # Prepares a directory for pid file.
+    #
+    def self.prepare_pid(pid)
+      pid = 'tmp/pids/server.pid' if pid.blank?
+      FileUtils.mkdir_p(File.dirname(pid))
+      File.expand_path(pid)
+    end
+
+    # Parses an array of server options.
+    #
+    def self.parse_server_options(options)
+      parsed_server_options = Array(options).map{ |option| option.split('=', 2) }.flatten
+      Hash[*parsed_server_options].symbolize_keys
+    end
+
+    # Detects Host and Port for Rack server.
+    #
+    def self.detect_address(options)
+      address = DEFAULT_ADDRESS.merge options.slice(:Host, :Port)
+      address[:Host] = options[:host] if options[:host].present?
+      address[:Port] = options[:port] if options[:port].present?
+      address
+    end
   end
 end

data/lib/padrino-core/version.rb

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

data/padrino-core.gemspec

@@ -23,22 +23,14 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rdoc_options  = ["--charset=UTF-8"]
 
-  # TODO remove after a couple versions
-  # s.post_install_message = "\e[32m" + ("*" * 20)
-  # s.post_install_message << "\n UPGRADE NOTES\n\n\e[31m When upgrading, please 'enable :sessions' for each application"
-  # s.post_install_message << " as shown here:\e[0m http://bit.ly/kODKMx\n"
-  # s.post_install_message << "\e[31m When upgrading, please 'register Padrino::Rendering' for each application"
-  # s.post_install_message << " as shown here:\e[0m https://gist.github.com/1d36a35794dbbd664ea4"
-  # s.post_install_message << "\n\e[32m" + ("*" * 20) + "\n\e[0m"
-
-  s.add_dependency("tilt", "~> 1.4.1")
+  s.add_dependency("padrino-support", Padrino.version)
   if ENV["SINATRA_EDGE"]
     s.add_dependency("sinatra")
   else
     s.add_dependency("sinatra", "~> 1.4.2")
   end
   s.add_dependency("http_router", "~> 0.11.0")
-  s.add_dependency("thor", "~> 0.17.0")
+  s.add_dependency("thor", "~> 0.18.0")
   s.add_dependency("activesupport", ">= 3.1")
   s.add_dependency("rack-protection", ">= 1.5.0")
 end