merb-core 0.9.4 → 0.9.5

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

@@ -1,12 +1,12 @@
 require Merb.framework_root / "merb-core" / "dispatch" / "default_exception" / "default_exception"
+
 module Merb
   class Dispatcher
     class << self
       include Merb::ControllerExceptions
     
       attr_accessor :use_mutex
-    
-      @@mutex = Mutex.new
+      
       @@work_queue = Queue.new
     
       def work_queue 
@@ -14,7 +14,7 @@ module Merb
       end  
     
       Merb::Dispatcher.use_mutex = ::Merb::Config[:use_mutex]
-    
+      
       # Dispatch the rack environment. ControllerExceptions are rescued here
       # and redispatched.
       #
@@ -26,148 +26,141 @@ module Merb
       # 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.handle
+      end      
+    end
+  end
+  
+  class Request
+    include Merb::ControllerExceptions
     
-        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
+    @@mutex = Mutex.new
+    
+    def handle
+      start = Time.now
+      Merb.logger.info "Started request handling: #{start.to_s}"
+  
+      find_route!
+      return redirect if redirects?
       
-        if klass.name == "Application"
-          raise NotFound, "The 'Application' controller has no public actions"
-        end
+      klass = controller
+      Merb.logger.debug("Routed to: #{params.inspect}")
       
-        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
-      # 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
+      unless klass < Controller
+        raise NotFound, 
+          "Controller '#{klass}' not found.\n" \
+          "If Merb tries to find a controller for static files, " \
+          "you may need to check your Rackup file, see the Problems " \
+          "section at: http://wiki.merbivore.com/pages/rack-middleware"
       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. 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]
-        
-        begin
-          e = request.exceptions.first
-          
-          if action_name = e.action_name
-            dispatch_action(Exceptions, action_name, request, e.class.status)
-          else
-            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
+      if klass == Application
+        raise NotFound, "The 'Application' controller has no public actions"
       end
     
-      # 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
+      controller = dispatch_action(klass, params[:action])
+      controller._benchmarks[:dispatch_time] = Time.now - start
+      Merb.logger.info controller._benchmarks.inspect
+      Merb.logger.flush
+      controller
+    rescue Object => exception
+      dispatch_exception(exception)
+    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
+      status, url = redirect_status, redirect_url
+      controller = Merb::Controller.new(self, 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
+    
+    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, status=200)
+      # build controller
+      controller = klass.new(self, status)
+      if Dispatcher.use_mutex
+        @@mutex.synchronize { controller._dispatch(action) }
+      else
+        controller._dispatch(action)
       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)
+      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. 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)
+      Merb.logger.error(Merb.exception(exception))
+      self.exceptions = [exception]
       
-        Merb.logger.info("Dispatcher redirecting to: #{url} (#{status})")
-        Merb.logger.flush
+      begin
+        e = exceptions.first
         
-        controller.headers['Location'] = url
-        controller.body = "<html><body>You are being <a href=\"#{url}\">redirected</a>.</body></html>"
-        controller
+        if action_name = e.action_name
+          dispatch_action(Exceptions, action_name, e.class.status)
+        else
+          Merb::Dispatcher::DefaultException.new(self, e.class.status)._dispatch
+        end
+      rescue Object => dispatch_issue
+        if e.same?(dispatch_issue) || exceptions.size > 5
+          Merb::Dispatcher::DefaultException.new(self, e.class.status)._dispatch
+        else
+          Merb.logger.error("Dispatching #{e.class} raised another error.")
+          Merb.logger.error(Merb.exception(dispatch_issue))
+          
+          exceptions.unshift dispatch_issue
+          retry
+        end
       end
-    
     end
   end
-end
+end

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

@@ -18,13 +18,13 @@ module Merb
     # 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
+    # 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.
+    # Initialize the request object.
     #
     # ==== Parameters
     # http_request<~params:~[], ~body:IO>:: 
@@ -519,8 +519,8 @@ module Merb
       end
       
       # ==== Parameters
-      # qs<String>:: The query string.
-      # d<String>:: The query string divider. Defaults to "&".
+      # query_string<String>:: The query string.
+      # delimiter<String>:: The query string divider. Defaults to "&".
       # preserve_order<Boolean>:: Preserve order of args. Defaults to false.
       #
       # ==== Returns
@@ -529,13 +529,13 @@ module Merb
       # ==== Examples
       #   query_parse("bar=nik&post[body]=heya")
       #     # => { :bar => "nik", :post => { :body => "heya" } }
-      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)
-        }
-        preserve_order ? qh : qh.to_mash
+      def query_parse(query_string, delimiter = '&;', preserve_order = false)
+        query = preserve_order ? Dictionary.new : {}
+        for pair in (query_string || '').split(/[#{delimiter}] */n)
+          key, value = unescape(pair).split('=',2)
+          normalize_params(query, key, value)
+        end
+        preserve_order ? query : query.to_mash
       end
     
       NAME_REGEX = /Content-Disposition:.* name="?([^\";]*)"?/ni.freeze

data/lib/merb-core/dispatch/router/behavior.rb

@@ -96,7 +96,7 @@ module Merb
 
       # Matches a +path+ and any number of optional request methods as
       # conditions of a route. Alternatively, +path+ can be a hash of
-      # conditions, in which case +conditions+ ignored.
+      # conditions, in which case +conditions+ is ignored.
       #
       # ==== Parameters
       #
@@ -108,12 +108,12 @@ module Merb
       #   within the regular expression syntax.
       #   +path+ is optional.
       # conditions<Hash>::
-      #   Addational conditions that the request must meet in order to match.
-      #   the keys must be methods that the Merb::Request instance will respond
+      #   Additional conditions that the request must meet in order to match.
+      #   The keys must be methods that the Merb::Request instance will respond
       #   to.  The value is the string or regexp that matched the returned value.
       #   Conditions are inherited by child routes.
       #
-      #   The Following have special meaning:
+      #   The following have special meaning:
       #   * :method -- Limit this match based on the request method. (GET,
       #     POST, PUT, DELETE)
       #   * :path -- Used internally to maintain URL form information
@@ -141,13 +141,13 @@ module Merb
       #     f.match("/baz").to(:action => "caz")
       #   end
       #
-      #   #match only of the browser string contains MSIE or Gecko
+      #   #match only if the browser string contains MSIE or Gecko
       #   r.match ('/foo', :user_agent => /(MSIE|Gecko)/ )
       #        .to({:controller=>'foo', :action=>'popular')
       #
       #   # Route GET and POST requests to different actions (see also #resources)
       #   r.match('/foo', :method=>:get).to(:action=>'show')
-      #   r.mathc('/foo', :method=>:post).to(:action=>'create')
+      #   r.match('/foo', :method=>:post).to(:action=>'create')
       #
       #   # match also takes regular expressions
       #

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

@@ -3,19 +3,19 @@ require 'merb-core/dispatch/router/behavior'
 require 'merb-core/dispatch/router/route'
 require 'merb-core/controller/mixins/responder'
 module Merb
-  # Router stores route definitions and finds first
-  # that matches incoming request URL.
+  # Router stores route definitions and finds the first
+  # route that matches the incoming request URL.
   #
   # Then information from route is used by dispatcher to
   # call action on the controller.
   #
   # ==== Routes compilation.
   #
-  # Most interesting method of Router (and heart of
+  # The most interesting method of Router (and heart of
   # route matching machinery) is match method generated
-  # on fly from routes definitions. It is called routes
+  # on the fly from routes definitions. It is called routes
   # compilation. Generated match method body contains
-  # one if/elsif statement that picks first matching route
+  # one if/elsif statement that picks the first matching route
   # definition and sets values to named parameters of the route.
   #
   # Compilation is synchronized by mutex.