merb-core 0.9.2 → 0.9.3

data/lib/merb-core/config.rb

@@ -21,7 +21,8 @@ module Merb
           :session_id_key         => "_session_id",
           :log_delimiter          => " ~ ",
           :log_auto_flush         => false,
-          :disabled_components    => []
+          :disabled_components    => [],
+          :deferred_actions       => []
         }
       end
 
@@ -90,7 +91,7 @@ module Merb
       # ==== Returns
       # String:: The config as YAML.
       def to_yaml
-        @configuration.to_yaml  
+        @configuration.to_yaml
       end
 
       # Sets up the configuration by storing the given settings.
@@ -120,7 +121,7 @@ module Merb
           opts.release = Merb::RELEASE
 
           opts.banner = "Usage: merb [uGdcIpPhmailLerkKX] [argument]"
-          opts.define_head "Merb Mongrel+ Erb. Lightweight replacement for ActionPack."
+          opts.define_head "Merb. Pocket rocket web framework"
           opts.separator '*'*80
           opts.separator 'If no flags are given, Merb starts in the foreground on port 4000.'
           opts.separator '*'*80
@@ -141,7 +142,7 @@ module Merb
             options[:cluster] = nodes
           end
 
-          opts.on("-I", "--init-file FILE", "Name of the file to load first") do |init_file|
+          opts.on("-I", "--init-file FILE", "File to use for initialization on load, defaults to config/init.rb") do |init_file|
             options[:init_file] = init_file
           end
 
@@ -161,14 +162,18 @@ module Merb
             options[:merb_root] = File.expand_path(root)
           end
 
-          opts.on("-a", "--adapter mongrel", "The rack adapter to use to run merb[mongrel, emongrel, thin, fastcgi, webrick, runner, irb]") do |adapter|
+          opts.on("-a", "--adapter mongrel", "The rack adapter to use to run merb[mongrel, emongrel, thin, ebb, fastcgi, webrick, runner, irb]") do |adapter|
             options[:adapter] = adapter
           end
 
+          opts.on("-R", "--rackup FILE", "Load an alternate Rack config file (default is config/rack.rb)") do |rackup|
+            options[:rackup] = rackup
+          end
+
           opts.on("-i", "--irb-console", "This flag will start merb in irb console mode. All your models and other classes will be available for you in an irb session.") do |console|
             options[:adapter] = 'irb'
           end
-          
+
           opts.on("-S", "--sandbox", "This flag will enable a sandboxed irb console. If your ORM supports transactions, all edits will be rolled back on exit.") do |sandbox|
             options[:sandbox] = true
           end
@@ -185,20 +190,20 @@ module Merb
             options[:environment] = env
           end
 
-          opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]", 
+          opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]",
           "Command-line option to run scripts and/or code in the merb app.") do |code_or_file|
             options[:runner_code] = code_or_file
             options[:adapter] = 'runner'
           end
 
           opts.on("-K", "--graceful PORT or all", "Gracefully kill one merb proceses by port number.  Use merb -K all to gracefully kill all merbs.") do |ports|
-            @configuration = defaults.merge(options)
-            Merb::Server.kill(ports, 1)
+            options[:action] = :kill
+            options[:port] = ports
           end
 
           opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number.  Use merb -k all to kill all merbs.") do |port|
-            @configuration = defaults.merge(options)
-            Merb::Server.kill(port, 9)
+            options[:action] = :kill_9
+            options[:port] = port
           end
 
           opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
@@ -206,7 +211,7 @@ module Merb
               options[:use_mutex] = false
             else
               options[:use_mutex] = true
-            end   
+            end
           end
 
           opts.on("-D", "--debugger", "Run merb using rDebug.") do
@@ -222,7 +227,7 @@ module Merb
           end
 
           opts.on("-?", "-H", "--help", "Show this help message") do
-            puts opts  
+            puts opts
             exit
           end
         end
@@ -249,7 +254,7 @@ module Merb
       def configure(&block)
         ConfigBlock.new(self, &block) if block_given?
       end
-      
+
       # Allows retrieval of single key config values via Merb.config.<key>
       # Allows single key assignment via Merb.config.<key> = ...
       #

data/lib/merb-core/controller/abstract_controller.rb

@@ -14,6 +14,7 @@
 # ==== Examples
 #   before :some_filter
 #   before :authenticate, :exclude => [:login, :signup]
+#   before :has_role, :with => ["Admin"], :exclude => [:index,:show]
 #   before Proc.new {|c| c.some_method }, :only => :foo
 #   before :authorize, :unless => logged_in?  
 #
@@ -89,7 +90,7 @@ class Merb::AbstractController
   # structure for your app.
   #
   # ==== Parameters
-  # action<~to_s>:: The controller action.
+  # context<~to_s>:: The controller context (the action or template name).
   # type<~to_s>:: The content type. Defaults to nil.
   # controller<~to_s>::
   #   The name of the controller. Defaults to controller_name.
@@ -98,9 +99,9 @@ class Merb::AbstractController
   # ==== Returns
   # String:: 
   #   Indicating where to look for the template for the current controller,
-  #   action, and content-type.
+  #   context, and content-type.
   #
-  # ==== Note
+  # ==== Notes
   # The type is irrelevant for controller-types that don't support
   # content-type negotiation, so we default to not include it in the
   # superclass.
@@ -114,8 +115,8 @@ class Merb::AbstractController
   # of controller/action.mime.type
   #---
   # @public
-  def _template_location(action, type = nil, controller = controller_name)
-    "#{controller}/#{action}"
+  def _template_location(context, type = nil, controller = controller_name)
+    controller ? "#{controller}/#{context}" : context
   end
 
   # ==== Returns
@@ -158,15 +159,6 @@ class Merb::AbstractController
       HERE
       super
     end
-    
-    # ==== Parameters
-    # layout<~to_s>:: The layout that should be used for this class
-    # 
-    # ==== Returns
-    # ~to_s:: The layout that was passed in
-    def layout(layout)
-      self._layout = layout
-    end
   end
   
   attr_accessor :_benchmarks, :_thrown_content
@@ -218,6 +210,7 @@ class Merb::AbstractController
     _call_filters(_after_filters) 
     @_benchmarks[:after_filters_time] = Time.now - start if _after_filters
     finalize_session
+    @body
   end
   
   # This method exists to provide an overridable hook for ActionArgs
@@ -247,7 +240,13 @@ class Merb::AbstractController
     (filter_set || []).each do |filter, rule|
       if _call_filter_for_action?(rule, action_name) && _filter_condition_met?(rule)
         case filter
-        when Symbol, String then send(filter)
+        when Symbol, String
+          if rule.key?(:with)
+            args = rule[:with]
+            send(filter, *args)
+          else
+            send(filter)
+          end
         when Proc           then self.instance_eval(&filter)
         end
       end
@@ -323,7 +322,7 @@ class Merb::AbstractController
   #   Filter options (see class documentation under <tt>Filter Options</tt>).
   # &block:: Currently ignored.
   #
-  # ==== Note
+  # ==== Notes
   # If the filter already exists, its options will be replaced with opts.
   def self.after(filter = nil, opts = {}, &block)
     add_filter(self._after_filters, filter, opts)
@@ -335,7 +334,7 @@ class Merb::AbstractController
   #   Filter options (see class documentation under <tt>Filter Options</tt>).
   # &block:: A block to use as a filter if filter is nil.
   #
-  # ==== Note
+  # ==== Notes
   # If the filter already exists, its options will be replaced with opts.
   def self.before(filter = nil, opts = {}, &block)
     add_filter(self._before_filters, filter || block, opts)

data/lib/merb-core/controller/exceptions.rb

@@ -58,7 +58,7 @@ module Merb
   #       "team@cowboys.com", 
   #       "Exception occured at #{Time.now}", 
   #       params[:exception])
-  #     render :inline => 'Something is wrong, but the team are on it!'
+  #     render 'Something is wrong, but the team are on it!'
   #   end
   #
   # Note: The special param[:exception] is available in all Exception actions 
@@ -101,135 +101,180 @@ module Merb
       # String:: The snake cased name of the error without the namespace.
       def name; self.class.name; end
 
-      # ==== Returns
-      # String:: The snake cased name of the class without the namespace.
-      def self.name
-        to_s.snake_case.split('::').last
-      end
+      # === Returns
+      # Integer:: The status-code of the error.
+      def status; self.class.status; end
+      alias :to_i :status
+
+      class << self
+
+        # ==== Returns
+        # String:: The snake cased name of the class without the namespace.
+        def name
+          self.to_s.split('::').last.snake_case
+        end
       
-      # Makes it possible to pass a status-code class to render :status.
-      #
-      # ==== Returns
-      # Fixnum:: The status code of this exception.
-      def self.to_i
-        STATUS
-      end
+        # Get the actual status-code for an Exception class.
+        #
+        # As usual, this can come from a constant upwards in
+        # the inheritance chain.
+        #
+        # ==== Returns
+        # Fixnum:: The status code of this exception.
+        def status
+          const_get(:STATUS) rescue 0
+        end
+        alias :to_i :status
+        
+        # Set the actual status-code for an Exception class.
+        #
+        # If possible, set the STATUS constant, and update
+        # any previously registered (inherited) status-code.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        def status=(num)
+          unless self.status?
+            register_status_code(self, num)
+            self.const_set(:STATUS, num.to_i)
+          end
+        end
       
-      # Registers any subclasses with status codes for easy lookup by
-      # set_status in Merb::Controller.
-      #
-      # Inheritance ensures this method gets inherited by any subclasses, so
-      # it goes all the way down the chain of inheritance.
-      #
-      # ==== Parameters
-      # 
-      # subclass<Merb::ControllerExceptions::Base>::
-      #   The Exception class that is inheriting from Merb::ControllerExceptions::Base
-      def self.inherited(subclass)
-        if subclass.const_defined?(:STATUS)
-          STATUS_CODES[subclass.name.snake_case.to_sym] = subclass.const_get(:STATUS)
+        # See if a status-code has been defined (on self explicitly).
+        #
+        # ==== Returns
+        # Boolean:: Whether the a status code has been set
+        def status?
+          self.const_defined?(:STATUS)
+        end
+      
+        # Registers any subclasses with status codes for easy lookup by
+        # set_status in Merb::Controller.
+        #
+        # Inheritance ensures this method gets inherited by any subclasses, so
+        # it goes all the way down the chain of inheritance.
+        #
+        # ==== Parameters
+        # 
+        # subclass<Merb::ControllerExceptions::Base>::
+        #   The Exception class that is inheriting from Merb::ControllerExceptions::Base
+        def inherited(subclass)
+          # don't set the constant yet - any class methods will be called after self.inherited
+          # unless self.status = ... is set explicitly, the status code will be inherited
+          register_status_code(subclass, self.status) if self.status?
+        end
+        
+        private
+        
+        # Register the status-code for an Exception class.
+        #
+        # ==== Parameters
+        # num<~to_i>:: The status code
+        def register_status_code(klass, code)
+          STATUS_CODES[klass.name.to_sym] = code.to_i
         end
+        
       end
     end
 
     class Informational                 < Merb::ControllerExceptions::Base; end
 
-      class Continue                    < Merb::ControllerExceptions::Informational; STATUS = 100; end
+      class Continue                    < Merb::ControllerExceptions::Informational; self.status = 100; end
 
-      class SwitchingProtocols          < Merb::ControllerExceptions::Informational; STATUS = 101; end
+      class SwitchingProtocols          < Merb::ControllerExceptions::Informational; self.status = 101; end
 
     class Successful                    < Merb::ControllerExceptions::Base; end
 
-      class OK                          < Merb::ControllerExceptions::Successful; STATUS = 200; end
+      class OK                          < Merb::ControllerExceptions::Successful; self.status = 200; end
 
-      class Created                     < Merb::ControllerExceptions::Successful; STATUS = 201; end
+      class Created                     < Merb::ControllerExceptions::Successful; self.status = 201; end
 
-      class Accepted                    < Merb::ControllerExceptions::Successful; STATUS = 202; end
+      class Accepted                    < Merb::ControllerExceptions::Successful; self.status = 202; end
 
-      class NonAuthoritativeInformation < Merb::ControllerExceptions::Successful; STATUS = 203; end
+      class NonAuthoritativeInformation < Merb::ControllerExceptions::Successful; self.status = 203; end
 
-      class NoContent                   < Merb::ControllerExceptions::Successful; STATUS = 204; end
+      class NoContent                   < Merb::ControllerExceptions::Successful; self.status = 204; end
 
-      class ResetContent                < Merb::ControllerExceptions::Successful; STATUS = 205; end
+      class ResetContent                < Merb::ControllerExceptions::Successful; self.status = 205; end
 
-      class PartialContent              < Merb::ControllerExceptions::Successful; STATUS = 206; end
+      class PartialContent              < Merb::ControllerExceptions::Successful; self.status = 206; end
 
     class Redirection                   < Merb::ControllerExceptions::Base; end
 
-      class MultipleChoices             < Merb::ControllerExceptions::Redirection; STATUS = 300; end
+      class MultipleChoices             < Merb::ControllerExceptions::Redirection; self.status = 300; end
 
-      class MovedPermanently            < Merb::ControllerExceptions::Redirection; STATUS = 301; end
+      class MovedPermanently            < Merb::ControllerExceptions::Redirection; self.status = 301; end
 
-      class MovedTemporarily            < Merb::ControllerExceptions::Redirection; STATUS = 302; end
+      class MovedTemporarily            < Merb::ControllerExceptions::Redirection; self.status = 302; end
 
-      class SeeOther                    < Merb::ControllerExceptions::Redirection; STATUS = 303; end
+      class SeeOther                    < Merb::ControllerExceptions::Redirection; self.status = 303; end
 
-      class NotModified                 < Merb::ControllerExceptions::Redirection; STATUS = 304; end
+      class NotModified                 < Merb::ControllerExceptions::Redirection; self.status = 304; end
 
-      class UseProxy                    < Merb::ControllerExceptions::Redirection; STATUS = 305; end
+      class UseProxy                    < Merb::ControllerExceptions::Redirection; self.status = 305; end
 
-      class TemporaryRedirect           < Merb::ControllerExceptions::Redirection; STATUS = 307; end
+      class TemporaryRedirect           < Merb::ControllerExceptions::Redirection; self.status = 307; end
 
     class ClientError                   < Merb::ControllerExceptions::Base; end
 
-      class BadRequest                  < Merb::ControllerExceptions::ClientError; STATUS = 400; end
+      class BadRequest                  < Merb::ControllerExceptions::ClientError; self.status = 400; end
 
-        class MultiPartParseError       < Merb::ControllerExceptions::BadRequest; end
+      class MultiPartParseError         < Merb::ControllerExceptions::BadRequest; end
 
-      class Unauthorized                < Merb::ControllerExceptions::ClientError; STATUS = 401; end
+      class Unauthorized                < Merb::ControllerExceptions::ClientError; self.status = 401; end
 
-      class PaymentRequired             < Merb::ControllerExceptions::ClientError; STATUS = 402; end
+      class PaymentRequired             < Merb::ControllerExceptions::ClientError; self.status = 402; end
 
-      class Forbidden                   < Merb::ControllerExceptions::ClientError; STATUS = 403; end
+      class Forbidden                   < Merb::ControllerExceptions::ClientError; self.status = 403; end
 
-      class NotFound                    < Merb::ControllerExceptions::ClientError; STATUS = 404; end
+      class NotFound                    < Merb::ControllerExceptions::ClientError; self.status = 404; end
 
-        class ActionNotFound            < Merb::ControllerExceptions::NotFound; end
+      class ActionNotFound              < Merb::ControllerExceptions::NotFound; end
 
-        class TemplateNotFound          < Merb::ControllerExceptions::NotFound; end
+      class TemplateNotFound            < Merb::ControllerExceptions::NotFound; end
 
-        class LayoutNotFound            < Merb::ControllerExceptions::NotFound; end
+      class LayoutNotFound              < Merb::ControllerExceptions::NotFound; end
 
-      class MethodNotAllowed            < Merb::ControllerExceptions::ClientError; STATUS = 405; end
+      class MethodNotAllowed            < Merb::ControllerExceptions::ClientError; self.status = 405; end
 
-      class NotAcceptable               < Merb::ControllerExceptions::ClientError; STATUS = 406; end
+      class NotAcceptable               < Merb::ControllerExceptions::ClientError; self.status = 406; end
 
-      class ProxyAuthenticationRequired < Merb::ControllerExceptions::ClientError; STATUS = 407; end
+      class ProxyAuthenticationRequired < Merb::ControllerExceptions::ClientError; self.status = 407; end
 
-      class RequestTimeout              < Merb::ControllerExceptions::ClientError; STATUS = 408; end
+      class RequestTimeout              < Merb::ControllerExceptions::ClientError; self.status = 408; end
 
-      class Conflict                    < Merb::ControllerExceptions::ClientError; STATUS = 409; end
+      class Conflict                    < Merb::ControllerExceptions::ClientError; self.status = 409; end
 
-      class Gone                        < Merb::ControllerExceptions::ClientError; STATUS = 410; end
+      class Gone                        < Merb::ControllerExceptions::ClientError; self.status = 410; end
 
-      class LengthRequired              < Merb::ControllerExceptions::ClientError; STATUS = 411; end
+      class LengthRequired              < Merb::ControllerExceptions::ClientError; self.status = 411; end
 
-      class PreconditionFailed          < Merb::ControllerExceptions::ClientError; STATUS = 412; end
+      class PreconditionFailed          < Merb::ControllerExceptions::ClientError; self.status = 412; end
 
-      class RequestEntityTooLarge       < Merb::ControllerExceptions::ClientError; STATUS = 413; end
+      class RequestEntityTooLarge       < Merb::ControllerExceptions::ClientError; self.status = 413; end
 
-      class RequestURITooLarge          < Merb::ControllerExceptions::ClientError; STATUS = 414; end
+      class RequestURITooLarge          < Merb::ControllerExceptions::ClientError; self.status = 414; end
 
-      class UnsupportedMediaType        < Merb::ControllerExceptions::ClientError; STATUS = 415; end
+      class UnsupportedMediaType        < Merb::ControllerExceptions::ClientError; self.status = 415; end
 
-      class RequestRangeNotSatisfiable  < Merb::ControllerExceptions::ClientError; STATUS = 416; end
+      class RequestRangeNotSatisfiable  < Merb::ControllerExceptions::ClientError; self.status = 416; end
 
-      class ExpectationFailed           < Merb::ControllerExceptions::ClientError; STATUS = 417; end
+      class ExpectationFailed           < Merb::ControllerExceptions::ClientError; self.status = 417; end
 
     class ServerError                   < Merb::ControllerExceptions::Base; end
 
-      class NotImplemented              < Merb::ControllerExceptions::ServerError; STATUS = 501; end
+      class NotImplemented              < Merb::ControllerExceptions::ServerError; self.status = 501; end
 
-      class BadGateway                  < Merb::ControllerExceptions::ServerError; STATUS = 502; end
+      class BadGateway                  < Merb::ControllerExceptions::ServerError; self.status = 502; end
 
-      class ServiceUnavailable          < Merb::ControllerExceptions::ServerError; STATUS = 503; end
+      class ServiceUnavailable          < Merb::ControllerExceptions::ServerError; self.status = 503; end
 
-      class GatewayTimeout              < Merb::ControllerExceptions::ServerError; STATUS = 504; end
+      class GatewayTimeout              < Merb::ControllerExceptions::ServerError; self.status = 504; end
 
-      class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; STATUS = 505; end
+      class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; self.status = 505; end
 
       class InternalServerError         < Merb::ControllerExceptions::ServerError #:doc: 
-        STATUS = 500
+        self.status = 500;
         # DEFAULT_TEMPLATE = ::Merb::Dispatcher::DEFAULT_ERROR_TEMPLATE
         def initialize(exception = nil)
           @exception = exception