padrino-core 0.9.29 → 0.10.0

data/bin/padrino

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-require 'rubygems' unless defined?(Gem) # Useful only on --dev mode
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup' if %w(Gemfile .components).all? { |f| File.exist?(f) }
 
 padrino_core_path = File.expand_path('../../lib', __FILE__)
 $:.unshift(padrino_core_path) if File.directory?(padrino_core_path) && !$:.include?(padrino_core_path)

data/lib/padrino-core.rb

@@ -80,7 +80,7 @@ module Padrino
         $KCODE='u'
       else
         Encoding.default_external = Encoding::UTF_8
-        Encoding.default_internal = Encoding::UTF_8
+        Encoding.default_internal = nil # Encoding::UTF_8
       end
       nil
     end

data/lib/padrino-core/application.rb

@@ -8,9 +8,6 @@ module Padrino
   #
   class Application < Sinatra::Base
     register Padrino::Routing   # Support for advanced routing, controllers, url_for
-    unless defined?(SKIP_PADRINO_RENDERING) && SKIP_PADRINO_RENDERING
-      register Padrino::Rendering # Support for enhanced rendering with template detection
-    end
 
     class << self
 
@@ -18,10 +15,13 @@ module Padrino
         logger.devel "Setup #{base}"
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
         base.default_configuration!
-        Padrino.require_dependencies File.join(base.root, "/models.rb")
-        Padrino.require_dependencies File.join(base.root, "/models/**/*.rb")
-        Padrino.require_dependencies File.join(base.root, "/lib.rb")
-        Padrino.require_dependencies File.join(base.root, "/lib/**/*.rb")
+        base.prerequisites.concat([
+          File.join(base.root, "/models.rb"),
+          File.join(base.root, "/models/**/*.rb"),
+          File.join(base.root, "/lib.rb"),
+          File.join(base.root, "/lib/**/*.rb")
+        ]).uniq!
+        Padrino.require_dependencies(base.prerequisites)
         super(base) # Loading the subclass inherited method
       end
 
@@ -112,7 +112,7 @@ module Padrino
       def run!(options={})
         return unless Padrino.load!
         Padrino.mount(self.to_s).to("/")
-        Padrino.run!
+        Padrino.run!(options)
       end
 
       ##
@@ -137,6 +137,23 @@ module Padrino
         ].map { |file| Dir[File.join(self.root, file)] }.flatten
       end
 
+      ##
+      # An array of file to load before your app.rb, basically are files wich our app depends on.
+      #
+      # By default we look for files:
+      #
+      #   yourapp/models.rb
+      #   yourapp/models/**/*.rb
+      #   yourapp/lib.rb
+      #   yourapp/lib/**/*.rb
+      #
+      # ==== Examples
+      #   MyApp.prerequisites << Padrino.root('my_app', 'custom_model.rb')
+      #
+      def prerequisites
+        @_prerequisites ||= []
+      end
+
       protected
         ##
         # Defines default settings for Padrino application
@@ -182,8 +199,10 @@ module Padrino
         #
         def default_filters!
           before do
-            @_content_type = :html
-            response['Content-Type'] = 'text/html;charset=utf-8'
+            unless @_content_type
+              @_content_type = :html
+              response['Content-Type'] = 'text/html;charset=utf-8'
+            end
           end
         end
 
@@ -220,5 +239,21 @@ module Padrino
           Padrino.require_dependencies(dependencies, :force => true)
         end
     end # self
+
+    # TODO Remove deprecated render inclusion in a few versions
+    # Detects if a user is incorrectly using 'render' and warns them about the fix
+    # In 0.10.0, Padrino::Rendering now has to be explicitly included in the application
+    def render(*args)
+      if !defined?(DEFAULT_RENDERING_OPTIONS) && !@_render_included &&
+          (args.size == 1 || (args.size == 2 && args[0].is_a?(String) && args[1].is_a?(Hash)))
+        logger.warn "[Deprecation] Please 'register Padrino::Rendering' for each application as shown here:
+          https://gist.github.com/1d36a35794dbbd664ea4 for 'render' to function as expected"
+        self.class.instance_eval { register Padrino::Rendering }
+        @_render_included = true
+        render(*args)
+      else # pass through, rendering is valid
+        super(*args)
+      end
+    end # render method
   end # Application
 end # Padrino

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

@@ -1,10 +1,13 @@
-$:.unshift '/Users/joshbuddy/Development/http_router/lib'
-
 require 'http_router' unless defined?(HttpRouter)
 require 'padrino-core/support_lite' unless defined?(SupportLite)
 
 class Sinatra::Request #:nodoc:
-  attr_accessor :route_obj
+  attr_accessor :route_obj, :runner
+
+  def runner=(runner)
+    @runner = runner
+    env['padrino.instance'] = runner
+  end
 
   def controller
     route_obj && route_obj.controller
@@ -12,7 +15,49 @@ class Sinatra::Request #:nodoc:
 end
 
 class HttpRouter #:nodoc:
-  attr_accessor :runner
+  def rewrite_partial_path_info(env, request); end
+  def rewrite_path_info(env, request); end
+
+  def process_destination_path(path, env)
+    env['padrino.instance'].instance_eval do
+      request.route_obj = path.route
+      @_response_buffer = nil
+      @params ||= {}
+      @params.update(env['router.params'])
+      @block_params = if path.route.is_a?(HttpRouter::RegexRoute)
+        params_list = env['router.request'].extra_env['router.regex_match'].to_a
+        params_list.shift
+        @params[:captures] = params_list
+        params_list
+      else
+        env['router.request'].params
+      end
+      # Provide access to the current controller to the request
+      # Now we can eval route, but because we have "throw halt" we need to be
+      # (en)sure to reset old layout and run controller after filters.
+      old_params = @params
+      parent_layout = @layout
+      successful = false
+      begin
+        filter! :before
+        (path.route.before_filters - self.class.filters[:before]).each { |filter| instance_eval(&filter)} if path.route.before_filters
+        # If present set current controller layout
+        @layout = path.route.use_layout if path.route.use_layout
+        @route = path.route
+        @route.custom_conditions.each { |blk| pass if instance_eval(&blk) == false } if @route.custom_conditions
+        @block_params = @block_params.slice(0, path.route.dest.arity) if path.route.dest.arity > 0
+        halt_response = catch(:halt) { route_eval(&path.route.dest) }
+        @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
+        successful = true
+        halt @_response_buffer
+      ensure
+        (@_pending_after_filters ||= []).concat(path.route.after_filters) if path.route.after_filters && successful
+        @layout = parent_layout
+        @params = old_params
+      end
+    end
+  end
+
   class Route #:nodoc:
     attr_reader :before_filters, :after_filters
     attr_accessor :custom_conditions, :use_layout, :controller, :cache
@@ -36,13 +81,43 @@ class HttpRouter #:nodoc:
     end
 
     def custom_conditions=(custom_conditions)
-      custom_conditions.each { |blk| arbitrary { |req, params| router.runner.instance_eval(&blk) != false } } if custom_conditions
       @custom_conditions = custom_conditions
     end
   end
 end
 
 module Padrino
+  class Filter
+    attr_reader :block
+
+    def initialize(mode, scoped_controller, options, args, &block)
+      @mode, @scoped_controller, @options, @args, @block = mode, scoped_controller, options, args, block
+    end
+
+    def apply?(request)
+      return true if @args.empty? && @options.empty?
+      detect = @args.any? do |arg|
+        case arg
+        when Symbol then request.route_obj.named == arg or request.route_obj.named == [@scoped_controller, arg].flatten.join("_").to_sym
+        else             arg === request.path_info
+        end
+      end || @options.any? { |name, val|
+        case name
+        when :agent then val === request.user_agent
+        else             val === request.send(name)
+        end
+      }
+      detect ^ !@mode
+    end
+
+    def to_proc
+      filter = self
+      proc {
+        instance_eval(&filter.block) if filter.apply?(request)
+      }
+    end
+  end
+
   ##
   # Padrino provides advanced routing definition support to make routes and url generation much easier.
   # This routing system supports named route aliases and easy access to url paths.
@@ -52,6 +127,7 @@ module Padrino
   #
   module Routing
     CONTENT_TYPE_ALIASES = { :htm => :html } unless defined?(CONTENT_TYPE_ALIASES)
+    ROUTE_PRIORITY = {:high => 0, :normal => 1, :low => 2}
 
     class UnrecognizedException < RuntimeError #:nodoc:
     end
@@ -132,6 +208,30 @@ module Padrino
       #     end
       #   end
       #
+      # You can specify conditions to run for all routes:
+      #
+      #   controller :conditions => {:protect => true} do
+      #     def self.protect(protected)
+      #       condition do
+      #         halt 403, "No secrets for you!" unless params[:key] == "s3cr3t"
+      #       end if protected
+      #     end
+      #
+      #     # This route will only return "secret stuff" if the user goes to
+      #     # `/private?key=s3cr3t`.
+      #     get("/private") { "secret stuff" }
+      #
+      #     # And this one, too!
+      #     get("/also-private") { "secret stuff" }
+      #
+      #     # But you can override the conditions for each route as needed.
+      #     # This route will be publicly accessible without providing the
+      #     # secret key.
+      #     get :index, :protect => false do
+      #       "Welcome!"
+      #     end
+      #   end
+      #
       # You can supply default values:
       #
       #   controller :lang => :de do
@@ -158,11 +258,12 @@ module Padrino
           @_use_format, original_use_format = options.delete(:use_format), @_use_format
           @_cache,      original_cache      = options.delete(:cache), @_cache
           @_map,        original_map        = options.delete(:map), @_map
+          @_conditions, original_conditions = options.delete(:conditions), @_conditions
           @_defaults,   original_defaults   = options, @_defaults
 
           # Application defaults
-          @filters,     original_filters = { :before => [], :after => [] }, @filters
-          @layout,      original_layout         = nil, @layout
+          @filters,     original_filters    = { :before => @filters[:before].dup, :after => @filters[:after].dup }, @filters
+          @layout,      original_layout     = nil, @layout
 
           instance_eval(&block)
 
@@ -173,13 +274,29 @@ module Padrino
           # Controller defaults
           @_controller, @_parents, @_cache = original_controller, original_parent, original_cache
           @_defaults, @_provides, @_map  = original_defaults, original_provides, original_map
-          @_use_format = original_use_format
+          @_conditions, @_use_format = original_conditions, original_use_format
         else
           include(*args) if extensions.any?
         end
       end
       alias :controllers :controller
 
+      def before(*args, &block)
+        add_filter :before, &(args.empty? ? block : construct_filter(*args, &block))
+      end
+
+      def after(*args, &block)
+        add_filter :after, &(args.empty? ? block : construct_filter(*args, &block))
+      end
+
+      def construct_filter(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        except = options.key?(:except) && Array(options.delete(:except))
+        raise("You cannot use except with other options specified") if except && (!args.empty? || !options.empty?)
+        options = except.last.is_a?(Hash) ? except.pop : {} if except
+        Filter.new(!except, @_controller, options, Array(except || args), &block)
+      end
+
       ##
       # Provides many parents with shallowing.
       #
@@ -220,17 +337,27 @@ module Padrino
       end
       alias :urls :router
 
-      def recognition_router
-        @recognition_router ||= HttpRouter.new
+      def compiled_router
+        if deferred_routes.empty?
+          router
+        else
+          deferred_routes.each { |_, routes| routes.each { |(route, dest)| route.to(dest) } }
+          @deferred_routes = nil
+          router
+        end
+      end
+
+      def deferred_routes
+        @deferred_routes ||= Hash[ROUTE_PRIORITY.values.sort.map{|p| [p, []]}]
       end
 
       def reset_router!
+        @deferred_routes = nil
         router.reset!
-        recognition_router.reset!
       end
 
       def recognize_path(path)
-        if response = @recognition_router.recognize(Rack::MockRequest.env_for(path))
+        if response = @router.recognize(Rack::MockRequest.env_for(path))
           [response.path.route.named, response.params]
         end
       end
@@ -253,15 +380,15 @@ module Padrino
           params = value_to_param(params)
         end
         url = if params_array.empty?
-          router.url(name, params)
+          compiled_router.url(name, params)
         else
-          router.url(name, *(params_array << params))
+          compiled_router.url(name, *(params_array << params))
         end
         url[0,0] = conform_uri(uri_root) if defined?(uri_root)
         url[0,0] = conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
         url = "/" if url.blank?
         url
-      rescue HttpRouter::UngeneratableRouteException
+      rescue HttpRouter::InvalidRouteException
         route_error = "route mapping for url(#{name.inspect}) could not be found!"
         raise Padrino::Routing::UnrecognizedException.new(route_error)
       end
@@ -275,6 +402,10 @@ module Padrino
         route('HEAD', path, *args, &block)
       end
 
+      def current_controller
+        @_controller && @_controller.last
+      end
+
       private
         # Parse params from the url method
         def value_to_param(value)
@@ -318,6 +449,7 @@ module Padrino
         #   get :list, :provides => :any                  # => "/list(.:format)"
         #   get :list, :provides => [:js, :json]          # => "/list.{!format,js|json}"
         #   get :list, :provides => [:html, :js, :json]   # => "/list(.{!format,js|json})"
+        #   get :list, :priority => :low                  # Defers route to be last
         #
         def route(verb, path, *args, &block)
           options = case args.size
@@ -340,21 +472,18 @@ module Padrino
           route_options[:provides] = @_provides if @_provides
           path, *route_options[:with] = path if path.is_a?(Array)
           path, name, options = *parse_route(path, route_options, verb)
+          options.reverse_merge!(@_conditions) if @_conditions
 
           # Sinatra defaults
-          define_method "#{verb} #{path}", &block
+          method_name = "#{verb} #{path}"
+          define_method(method_name, &block)
           unbound_method = instance_method("#{verb} #{path}")
+          remove_method(method_name)
 
-          block =
-            if block.arity != 0
-              block_arity = block.arity
-              proc {
-                @block_params = @block_params.slice(0, block_arity) if block_arity > 0
-                unbound_method.bind(self).call(*@block_params)
-              }
-            else
+          block_arity = block.arity
+          block = block_arity != 0 ?
+              proc { @block_params = @block_params[0, block_arity]; unbound_method.bind(self).call(*@block_params) } :
               proc { unbound_method.bind(self).call }
-            end
 
           invoke_hook(:route_added, verb, path, block)
 
@@ -362,6 +491,8 @@ module Padrino
           route = router.add(path)
 
           route.name(name) if name
+          priority_name = options.delete(:priority) || :normal
+          priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
           route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
           route.send(verb.downcase.to_sym)
           route.host(options.delete(:host)) if options.key?(:host)
@@ -377,40 +508,25 @@ module Padrino
             end
           end
 
-          recognition_router.add(path).name(name).to(name)
-
           # Add Sinatra conditions
-          options.each { |option, args|
-            if route.respond_to?(option)
-              route.send(option, *args)
-            else
-              send(option, *args)
-            end
-          }
+          options.each { |o, a| route.respond_to?(o) ? route.send(o, *a) : send(o, *a) }
           conditions, @conditions = @conditions, []
           route.custom_conditions = conditions
 
           invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
 
           # Add Application defaults
+          route.before_filters = @filters[:before]
+          route.after_filters  = @filters[:after]
           if @_controller
-            route.before_filters = @filters[:before]
-            route.after_filters  = @filters[:after]
-            route.use_layout     = @layout
-            route.controller     = Array(@_controller).first.to_s
-          else
-            route.before_filters = @filters[:before] || []
-            route.after_filters  = @filters[:after]  || []
+            route.use_layout = @layout
+            route.controller = Array(@_controller).first.to_s
           end
 
-          route.to(block)
+          deferred_routes[priority] << [route, block]
           route
         end
 
-        def current_controller
-          @_controller && @_controller.last
-        end
-
         ##
         # Returns the final parsed route details (modified to reflect all Padrino options)
         # given the raw route. Raw route passed in could be a named alias or a string and
@@ -555,11 +671,7 @@ module Padrino
             # per rfc2616-sec14:
             # Assume */* if no ACCEPT header is given.
             catch_all = (accepts.delete "*/*" || accepts.empty?)
-            if accepts.empty?
-              matching_types  = mime_types.slice(0,1)
-            else
-              matching_types  = (accepts & mime_types)
-            end
+            matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
 
             if params[:format]
               accept_format = params[:format]
@@ -668,51 +780,29 @@ module Padrino
       end
 
       private
-        ##
-        # Compatibility with http_router
-        #
+        def dispatch!
+          static! if settings.static? && (request.get? || request.head?)
+          route!
+        rescue Sinatra::NotFound => boom
+          handle_not_found!(boom)
+        rescue ::Exception => boom
+          handle_exception!(boom)
+        ensure
+          @_pending_after_filters.each { |filter| instance_eval(&filter)} if @_pending_after_filters
+        end
+
         def route!(base=self.class, pass_block=nil)
-          base.router.runner = self
-          if base.router and match = base.router.recognize(@request.env) { |match|
-            request.route_obj = match.path.route
-            @_response_buffer = nil
-            if match.path.route.is_a?(HttpRouter::RegexRoute)
-              params_list = match.request.extra_env['router.regex_match'].to_a
-              params_list.shift
-              @block_params = params_list
-              @params.update({:captures => params_list}.merge(@params || {}))
-            else
-              @block_params = match.param_values
-              @params.update(match.params.merge(@params || {}))
-            end
-            parent_layout = @layout
-            @params ||= {}
-            @layout = match.path.route.use_layout if match.path.route.use_layout
-            # Provide access to the current controller to the request
-            # Now we can eval route, but because we have "throw halt" we need to be
-            # (en)sure to reset old layout and run controller after filters.
-            begin
-              old_params = @params
-              match.path.route.before_filters.each { |filter| instance_eval(&filter) } if match.path.route.before_filters
-              # If present set current controller layout
-              @route = match.path.route
-              @block_params = @block_params.slice(0, match.path.route.dest.arity) if match.path.route.dest.arity > 0
-              match.acceptance_response = catch(:halt) { route_eval(&match.path.route.dest) } || ''
-            ensure
-              @layout = parent_layout
-              (@_pending_after_filters ||= []).concat(match.path.route.after_filters) if match.path.route.after_filters
-              @params = old_params
-            end
-          }
-            if match.respond_to?(:path)
-              throw :halt, @_response_buffer = match.acceptance_response
-            elsif match.respond_to?(:each)
+          @request.env['padrino.instance'] = self
+          if base.compiled_router and match = base.router.call(@request.env)
+            if match.respond_to?(:each)
               route_eval do
                 match[1].each {|k,v| response[k] = v}
                 status match[0]
                 route_missing if match[0] == 404
               end
             end
+          else
+            filter! :before
           end
 
           # Run routes defined in superclass.
@@ -725,7 +815,6 @@ module Padrino
 
           route_missing
         ensure
-          @_pending_after_filters.each { |aft| instance_eval(&aft) } if @_pending_after_filters
         end
     end # InstanceMethods
   end # Routing