merb-core 0.9.3 → 0.9.4

data/lib/merb-core/dispatch/dispatcher.rb

@@ -1,241 +1,173 @@
-class Merb::Dispatcher
-  DEFAULT_ERROR_TEMPLATE = File.expand_path(File.dirname(__FILE__) / 'exceptions.html')
-  
-  class << self
+require Merb.framework_root / "merb-core" / "dispatch" / "default_exception" / "default_exception"
+module Merb
+  class Dispatcher
+    class << self
+      include Merb::ControllerExceptions
     
-    attr_accessor :use_mutex
+      attr_accessor :use_mutex
     
-    @@mutex = Mutex.new
-    Merb::Dispatcher.use_mutex = ::Merb::Config[:use_mutex]
+      @@mutex = Mutex.new
+      @@work_queue = Queue.new
     
-    # This is where we grab the incoming request REQUEST_URI and use that in
-    # the merb RouteMatcher to determine which controller and method to run.
-    # Returns a 2 element tuple of: [controller, action]
-    #
-    # ControllerExceptions are rescued here and redispatched.
-    #
-    # ==== Parameters
-    # rack_env<Rack::Environment>::
-    #   The rack environment, which is used to instantiate a Merb::Request
-    # response<IO>::
-    #   An IO object to hold the response
-    #
-    # ==== Returns
-    # Array[Merb::Controller, Symbol]::
-    #   An array containing the Merb::Controller and the action that was
-    #   dispatched to.
-    def handle(rack_env)
-      start   = Time.now
-      request = Merb::Request.new(rack_env)
-      
-      route_index, route_params = Merb::Router.match(request)
-      
-      if route_params.empty?
-        raise ::Merb::ControllerExceptions::NotFound, "No routes match the request, #{request.uri}"
-      end
-      request.route_params = route_params
-      request.params.merge! route_params
-            
-      controller_name = (route_params[:namespace] ? route_params[:namespace] + '/' : '') + route_params[:controller]
-      
-      unless controller_name
-        raise Merb::ControllerExceptions::NotFound, "Route matched, but route did not specify a controller" 
-      end
-      
-      Merb.logger.debug("Routed to: #{request.route_params.inspect}")
-
-      cnt = controller_name.snake_case.to_const_string
+      def work_queue 
+        @@work_queue
+      end  
+    
+      Merb::Dispatcher.use_mutex = ::Merb::Config[:use_mutex]
+    
+      # Dispatch the rack environment. ControllerExceptions are rescued here
+      # and redispatched.
+      #
+      # ==== Parameters
+      # rack_env<Rack::Environment>::
+      #   The rack environment, which is used to instantiate a Merb::Request
+      #
+      # ==== Returns
+      # Merb::Controller::
+      #   The Merb::Controller that was dispatched to
+      def handle(request)
+        start = Time.now
+        Merb.logger.info "Started request handling: #{start.to_s}"
+    
+        request.find_route!
+        return redirect(request) if request.redirects?
+        
+        klass = request.controller
+        Merb.logger.debug("Routed to: #{request.params.inspect}")
+        
+        unless klass < Controller
+          raise NotFound, 
+            "Controller '#{klass}' not found.\n" <<
+            "If Merb tries to look for a controller for static files, " <<
+            "you way need to check up your Rackup file, see the Problems " <<
+            "section at: http://wiki.merbivore.com/pages/rack-middleware"
+        end
       
-      if !Merb::Controller._subclasses.include?(cnt)
-        raise Merb::ControllerExceptions::NotFound, "Controller '#{cnt}' not found"
-      end
-      if cnt == "Application"
-        raise Merb::ControllerExceptions::NotFound, "The 'Application' controller has no public actions"
-      end
-
-      begin
-        klass = Object.full_const_get(cnt)
-      rescue NameError
-        raise Merb::ControllerExceptions::NotFound
-      end
-
-      Merb.logger.info("Params: #{klass._filter_params(request.params).inspect}")
-
-      action = route_params[:action]
-
-      if route_index && route = Merb::Router.routes[route_index]
-        #Fixate the session ID if it is enabled on the route
-        if route.allow_fixation? && request.params.key?(Merb::Controller._session_id_key)
-          request.cookies[Merb::Controller._session_id_key] = request.params[Merb::Controller._session_id_key]
+        if klass.name == "Application"
+          raise NotFound, "The 'Application' controller has no public actions"
         end
-      end      
-
-      controller = dispatch_action(klass, action, request)
-      controller._benchmarks[:dispatch_time] = Time.now - start  
-      Merb.logger.info controller._benchmarks.inspect
-      Merb.logger.flush
-
-      controller
-    # this is the custom dispatch_exception; it allows failures to still be dispatched
-    # to the error controller
-    rescue => exception
-      Merb.logger.error(Merb.exception(exception))
-      unless request.xhr?
-        exception = controller_exception(exception)
-        dispatch_exception(request, exception)
-      else
-        Struct.new(:headers, :status, :body).new({}, 500,
-          <<-HERE
-#{exception.message}
- 
-Params:
-#{(request.params || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
- 
-Session:
-#{(request.session || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
- 
-Cookies:
-#{(request.cookies || {}).map { |p,v| "  #{p}: #{v}\n"}.join("\n")}
- 
-Stacktrace:
-#{exception.backtrace.join("\n")}
-          HERE
-        )
-      end
-    end
+      
+        controller = dispatch_action(klass, request.params[:action], request)
+        controller._benchmarks[:dispatch_time] = Time.now - start
+        Merb.logger.info controller._benchmarks.inspect
+        Merb.logger.flush
+        controller
+      rescue Object => exception
+        dispatch_exception(exception, request) 
+     end
     
-    private
-    # Setup the controller and call the chosen action 
-    #
-    # ==== Parameters
-    # klass<Merb::Controller>:: The controller class to dispatch to.
-    # action<Symbol>:: The action to dispatch.
-    # request<Merb::Request>::
-    #   The Merb::Request object that was created in #handle
-    # response<IO>:: The response object passed in from Mongrel
-    # status<Integer>:: The status code to respond with.
-    #
-    # ==== Returns
-    # Array[Merb::Controller, Symbol]::
-    #   An array containing the Merb::Controller and the action that was
-    #   dispatched to.
-    def dispatch_action(klass, action, request, status=200)
-      # build controller
-      controller = klass.new(request, status)
-      if use_mutex
-        @@mutex.synchronize { controller._dispatch(action) }
-      else
-        controller._dispatch(action)
+      private
+      # Setup the controller and call the chosen action 
+      #
+      # ==== Parameters
+      # klass<Merb::Controller>:: The controller class to dispatch to.
+      # action<Symbol>:: The action to dispatch.
+      # request<Merb::Request>::
+      #   The Merb::Request object that was created in #handle
+      # status<Integer>:: The status code to respond with.
+      #
+      # ==== Returns
+      # Merb::Controller::
+      #   The Merb::Controller that was dispatched to.
+      def dispatch_action(klass, action, request, status=200)
+        # build controller
+        controller = klass.new(request, status)
+        if use_mutex
+          @@mutex.synchronize { controller._dispatch(action) }
+        else
+          controller._dispatch(action)
+        end
+        controller
       end
-      controller
-    end
     
-    # Re-route the current request to the Exception controller if it is
-    # available, and try to render the exception nicely.  
-    #
-    # You can handle exceptions by implementing actions for specific
-    # exceptions such as not_found or for entire classes of exceptions
-    # such as client_error
-    #
-    # If it is not available then just render a simple text error.
-    #
-    # ==== Parameters
-    # request<Merb::Request>:: 
-    #   The request object associated with the failed request.
-    # response<IO>::
-    #   The response object to put the response into.
-    # exception<Object>::
-    #   The exception object that was created when trying to dispatch the
-    #   original controller.
-    #
-    # ==== Returns
-    # Array[Merb::Controller, String]::
-    #   An array containing the Merb::Controller and the name of the exception
-    #   that triggrered #dispatch_exception. For instance, a NotFound exception
-    #   will be "not_found".
-    def dispatch_exception(request, exception)
-      exception_klass = exception.class
-      begin
-        klass = ::Exceptions rescue Merb::Controller
-        request.params[:original_params] = request.params.dup rescue {}
-        request.params[:original_session] = request.session.dup rescue {}
-        request.params[:original_cookies] = request.cookies.dup rescue {}
-        request.params[:exception] = exception
-        request.params[:action] = exception_klass.name
-        
-        dispatch_action(klass, exception_klass.name, request, exception.class.status)
-      rescue => dispatch_issue       
-        dispatch_issue = controller_exception(dispatch_issue)  
-        # when no action/template exist for an exception, or an
-        # exception occurs on an InternalServerError the message is
-        # rendered as simple text.
+      # Re-route the current request to the Exception controller if it is
+      # available, and try to render the exception nicely.  
+      #
+      # You can handle exceptions by implementing actions for specific
+      # exceptions such as not_found or for entire classes of exceptions
+      # such as client_error. You can also implement handlers for 
+      # exceptions outside the Merb exception hierarchy (e.g.
+      # StandardError is caught in standard_error).
+      #
+      # ==== Parameters
+      # request<Merb::Request>:: 
+      #   The request object associated with the failed request.
+      # exception<Object>::
+      #   The exception object that was created when trying to dispatch the
+      #   original controller.
+      #
+      # ==== Returns
+      # Exceptions::
+      #   The Merb::Controller that was dispatched to. 
+      def dispatch_exception(exception, request)
+        Merb.logger.error(Merb.exception(exception))
+        request.exceptions = [exception]
         
-        # ControllerExceptions raised from exception actions are 
-        # dispatched back into the Exceptions controller
-        if dispatch_issue.is_a?(Merb::ControllerExceptions::NotFound)
-          # If a handler for a specific exception is not found, keep retrying 
-          # with the more general cases until we reach the base exception.
-          unless exception_klass == Merb::ControllerExceptions::Base
-            exception_klass = exception_klass.superclass
-            retry
+        begin
+          e = request.exceptions.first
+          
+          if action_name = e.action_name
+            dispatch_action(Exceptions, action_name, request, e.class.status)
           else
-            dispatch_default_exception(klass, request, exception)
-          end       
-        elsif request.params[:exception].is_a?(dispatch_issue.class)
-          dispatch_default_exception(klass, request, dispatch_issue)
-        elsif dispatch_issue.is_a?(Merb::ControllerExceptions::InternalServerError)
-          dispatch_default_exception(klass, request, dispatch_issue)
-        else
-          exception = dispatch_issue
-          retry
+            dispatch_default_exception(request, e.class.status)
+          end          
+        rescue Object => dispatch_issue
+          if e.same?(dispatch_issue)
+            dispatch_default_exception(request, e.class.status)
+          else
+            Merb.logger.error("Dispatching #{e.class} raised another error.")
+            Merb.logger.error(Merb.exception(dispatch_issue))
+            
+            request.exceptions.unshift dispatch_issue
+            retry
+          end
         end
       end
-    end
     
-    # If no custom actions are available to render an exception then the errors
-    # will end up here for processing
-    #
-    # ==== Parameters
-    # klass<Merb::Controller>:: 
-    #   The class of the controller to use for exception dispatch.
-    # request<Merb::Request>::
-    #   The Merb request that produced the original error.
-    # response<IO>::
-    #   The response object that the response will be put into.
-    # e<Exception>::
-    #   The exception that caused #dispatch_exception to be called.
-    #
-    # ==== Returns
-    # Array[Merb::Controller, String]::
-    #   An array containing the Merb::Controller that was dispatched to and the
-    #   error's name. For instance, a NotFound error's name is "not_found".
-    def dispatch_default_exception(klass, request, e)
-      controller = klass.new(request, e.class.status)
-      if e.is_a? Merb::ControllerExceptions::Redirection
-        controller.headers.merge!('Location' => e.message)
-        controller.body = %{ } #fix
-      else
-        controller.instance_variable_set("@exception", e) # for ERB
-        controller.instance_variable_set("@exception_name", e.name.split("_").map {|x| x.capitalize}.join(" "))
-        controller.body = controller.send(Merb::Template.template_for(DEFAULT_ERROR_TEMPLATE))
+      # If no custom actions are available to render an exception then the errors
+      # will end up here for processing
+      #
+      # ==== Parameters
+      # request<Merb::Request>::
+      #   The Merb request that produced the original error.
+      # status<Integer>::
+      #   The status code to return with the Exception.
+      #
+      # ==== Returns
+      # Merb::Dispatcher::DefaultException::
+      #   The DefaultException that was dispatched to.
+      def dispatch_default_exception(request, status)
+        Merb::Dispatcher::DefaultException.new(request, status)._dispatch
+      end
+
+      # Set up a faux controller to do redirection from the router 
+      #
+      # ==== Parameters
+      # request<Merb::Request>::
+      #   The Merb::Request object that was created in #handle
+      # status<Integer>::
+      #   The status code to return with the controller
+      # url<String>::
+      #   The URL to return
+      #
+      # ==== Example
+      # r.match("/my/old/crusty/url").redirect("http://example.com/index.html")
+      #
+      # ==== Returns
+      # Merb::Controller::
+      #   Merb::Controller set with redirect headers and a 301/302 status
+      def redirect(request)
+        status, url = request.redirect_status, request.redirect_url
+        controller = Merb::Controller.new(request, status)
+      
+        Merb.logger.info("Dispatcher redirecting to: #{url} (#{status})")
+        Merb.logger.flush
+        
+        controller.headers['Location'] = url
+        controller.body = "<html><body>You are being <a href=\"#{url}\">redirected</a>.</body></html>"
+        controller
       end
-      controller
-    end
-    
-    # Wraps any non-ControllerException errors in an InternalServerError ready
-    # for displaying over HTTP.
-    #
-    # ==== Parameters
-    # e<Exception>::
-    #   The exception that caused #dispatch_exception to be called.
-    #
-    # ==== Returns
-    # Merb::InternalServerError::
-    #   An internal server error wrapper for the exception.
-    def controller_exception(e)
-      e.kind_of?(Merb::ControllerExceptions::Base) ?
-        e : Merb::ControllerExceptions::InternalServerError.new(e) 
-    end    
     
+    end
   end
 end

data/lib/merb-core/dispatch/request.rb

@@ -1,15 +1,29 @@
+require 'tempfile'
+
 module Merb
   
   class Request
     # def env def session def route_params
-    attr_accessor :env, :session, :route_params
+    attr_accessor :env, :session, :exceptions, :route
+    attr_reader :route_params
     
-    # by setting these to false, auto-parsing is disabled; this way you can do your own parsing instead
-    cattr_accessor :parse_multipart_params, :parse_json_params, :parse_xml_params
+    # by setting these to false, auto-parsing is disabled; this way you can
+    # do your own parsing instead
+    cattr_accessor :parse_multipart_params, :parse_json_params,
+      :parse_xml_params
     self.parse_multipart_params = true
     self.parse_json_params = true
     self.parse_xml_params = true
     
+    # Flash, and some older browsers can't use arbitrary
+    # request methods -- i.e., are limited to GET/POST.
+    # These user-agents can make POST requests in combination
+    # with these overrides to participate fully in REST
+    # Common examples are _method or fb_sig_request_method
+    # in the params, or an X-HTTP-Method-Override header
+    cattr_accessor :http_method_overrides
+    self.http_method_overrides = []
+    
     # Initial the request object.
     #
     # ==== Parameters
@@ -21,25 +35,46 @@ module Merb
       @route_params = {}
     end
     
-    METHODS = %w{get post put delete head}
+    def controller
+      unless params[:controller]
+        raise ControllerExceptions::NotFound, 
+          "Route matched, but route did not specify a controller.\n" +
+          "Did you forgot to add :controller => \"people\" or :controller " +
+          "segment to route definition?\nHere is what's specified:\n" + 
+          request.route_params.inspect
+      end
+      path = [params[:namespace], params[:controller]].compact.join("/")
+      controller = path.snake_case.to_const_string
+      
+      begin
+        Object.full_const_get(controller)
+      rescue NameError => e
+        msg = "Controller class not found for controller `#{path}'"
+        Merb.logger.warn!(msg)
+        raise ControllerExceptions::NotFound, msg
+      end
+    end
+    
+    METHODS = %w{get post put delete head options}
 
     # ==== Returns
-    # Symbol:: The name of the request method, e.g. :get.
+    # <Symbol>:: The name of the request method, e.g. :get.
     #
     # ==== Notes
-    # If the method is post, then the +_method+ param will be checked for
-    # masquerading method.
+    # If the method is post, then the blocks specified in
+    # http_method_overrides will be checked for the masquerading method.
+    # The block will get the controller yielded to it.  The first matching workaround wins.
+    # To disable this behavior, set http_method_overrides = []
     def method
       @method ||= begin
         request_method = @env['REQUEST_METHOD'].downcase.to_sym
         case request_method
-        when :get, :head, :put, :delete
+        when :get, :head, :put, :delete, :options
           request_method
         when :post
-          if self.class.parse_multipart_params
-            m = body_and_query_params.merge(multipart_params)['_method']
-          else  
-            m = body_and_query_params['_method']
+          m = nil
+          self.class.http_method_overrides.each do |o|
+            m ||= o.call(self); break if m
           end
           m.downcase! if m
           METHODS.include?(m) ? m.to_sym : :post
@@ -54,6 +89,39 @@ module Merb
     METHODS.each do |m|
       class_eval "def #{m}?() method == :#{m} end"
     end
+
+    # Find route using requested URI and merges route
+    # parameters (:action, :controller and named segments)
+    # into request params hash.
+    def find_route!
+      @route, @route_params = Merb::Router.route_for(self)
+      @params.merge! @route_params
+    end
+
+    # Redirect status of route matched this request.
+    #
+    # ==== Returns
+    # Integer::
+    #   The URL to redirect to if the route redirects
+    def redirect_status
+      route.redirect_status
+    end
+
+    # Returns redirect url of route matched this request.
+    #
+    # ==== Returns
+    # <String>:: redirect url of route matched this request
+    def redirect_url
+      route.redirect_url
+    end
+
+    # Returns true if matched route does immediate redirection.
+    #
+    # ==== Returns
+    # <Boolean>:: if matched route does immediate redirection.
+    def redirects?
+      route.redirects?
+    end
     
     private
     
@@ -77,7 +145,7 @@ module Merb
     end
 
     # ==== Returns
-    # Hash::
+    # Mash::
     #   The parameters gathered from the query string and the request body,
     #   with parameters in the body taking precedence.
     def body_and_query_params
@@ -98,9 +166,9 @@ module Merb
     def multipart_params
       @multipart_params ||= 
         begin
-          # if the content-type is multipart and there's stuff in the body,
+          # if the content-type is multipart
           # parse the multipart. Otherwise return {}
-          if (Merb::Const::MULTIPART_REGEXP =~ content_type && @body.size > 0)
+          if (Merb::Const::MULTIPART_REGEXP =~ content_type)
             self.class.parse_multipart(@body, $1, content_length)
           else
             {}
@@ -113,10 +181,17 @@ module Merb
 
     # ==== Returns
     # Hash:: Parameters from body if this is a JSON request.
+    #
+    # ==== Notes
+    # If the JSON object parses as a Hash, it will be merged with the
+    # parameters hash.  If it parses to anything else (such as an Array, or
+    # if it inflates to an Object) it will be accessible via the inflated_object
+    # parameter.
     def json_params
       @json_params ||= begin
         if Merb::Const::JSON_MIME_TYPE_REGEXP.match(content_type)
-          JSON.parse(raw_post)
+          jobj = JSON.parse(raw_post) rescue Mash.new
+          jobj.kind_of?(Hash) ? jobj : { :inflated_object => jobj }
         end
       end
     end
@@ -133,7 +208,7 @@ module Merb
     
     public
     # ==== Returns
-    # Hash:: All request parameters.
+    # Mash:: All request parameters.
     #
     # ==== Notes
     # The order of precedence for the params is XML, JSON, multipart, body and
@@ -147,6 +222,15 @@ module Merb
         h
       end
     end
+    
+    def message
+      return {} unless params[:_message]
+      begin
+        Marshal.load(Merb::Request.unescape(params[:_message]).unpack("m").first)
+      rescue ArgumentError
+        {}
+      end
+    end
 
     # Resets the params to a nil value.
     def reset_params!
@@ -156,7 +240,14 @@ module Merb
     # ==== Returns
     # Hash:: The cookies for this request.
     def cookies
-      @cookies ||= self.class.query_parse(@env[Merb::Const::HTTP_COOKIE], ';,')
+      @cookies ||= begin 
+        cookies = self.class.query_parse(@env[Merb::Const::HTTP_COOKIE], ';,')
+        if route && route.allow_fixation? && params.key?(Merb::Controller._session_id_key)
+          Merb.logger.info("Fixated session id: #{Merb::Controller._session_id_key}")
+          cookies[Merb::Controller._session_id_key] = params[Merb::Controller._session_id_key]
+        end
+        cookies
+      end
     end
 
     # ==== Returns
@@ -210,10 +301,16 @@ module Merb
       @env['HTTP_REFERER']
     end
     
+    # ==== Returns
+    # String:: The full URI, including protocol and host
+    def full_uri
+      protocol + host + uri
+    end
+    
     # ==== Returns
     # String:: The request URI.
     def uri
-      @env['REQUEST_URI'] || @env['REQUEST_PATH']
+      @env['REQUEST_PATH'] || @env['REQUEST_URI'] || path_info
     end
 
     # ==== Returns
@@ -366,7 +463,7 @@ module Merb
     class << self
       
       # ==== Parameters
-      # value<Array, Hash, ~to_s>:: The value for the query string.
+      # value<Array, Hash, Dictionary ~to_s>:: The value for the query string.
       # prefix<~to_s>:: The prefix to add to the query string keys.
       #
       # ==== Returns
@@ -390,7 +487,7 @@ module Merb
           value.map { |v|
             params_to_query_string(v, "#{prefix}[]")
           } * "&"
-        when Hash
+        when Hash, Dictionary
           value.map { |k, v|
             params_to_query_string(v, prefix ? "#{prefix}[#{Merb::Request.escape(k)}]" : Merb::Request.escape(k))
           } * "&"
@@ -424,18 +521,21 @@ module Merb
       # ==== Parameters
       # qs<String>:: The query string.
       # d<String>:: The query string divider. Defaults to "&".
+      # preserve_order<Boolean>:: Preserve order of args. Defaults to false.
       #
       # ==== Returns
-      # Mash:: The parsed query string.
+      # Mash:: The parsed query string (Dictionary if preserve_order is set).
       #
       # ==== Examples
       #   query_parse("bar=nik&post[body]=heya")
       #     # => { :bar => "nik", :post => { :body => "heya" } }
-      def query_parse(qs, d = '&;')
-        (qs||'').split(/[#{d}] */n).inject({}) { |h,p| 
+      def query_parse(qs, d = '&;', preserve_order = false)
+        qh = preserve_order ? Dictionary.new : {}
+        (qs||'').split(/[#{d}] */n).inject(qh) { |h,p| 
           key, value = unescape(p).split('=',2)
           normalize_params(h, key, value)
-        }.to_mash
+        }
+        preserve_order ? qh : qh.to_mash
       end
     
       NAME_REGEX = /Content-Disposition:.* name="?([^\";]*)"?/ni.freeze
@@ -464,6 +564,7 @@ module Merb
         bufsize = 16384
         content_length -= boundary_size
         status = input.read(boundary_size)
+        return {} if status == nil || status.empty?
         raise ControllerExceptions::MultiPartParseError, "bad content body:\n'#{status}' should == '#{boundary + EOL}'"  unless status == boundary + EOL
         rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/
         loop {