wycats-merb-core 0.9.8 → 0.9.9

data/lib/merb-core/config.rb

@@ -14,15 +14,18 @@ module Merb
           :port                   => "4000",
           :adapter                => "runner",
           :reload_classes         => true,
+          :fork_for_class_load    => !RUBY_PLATFORM.in?("windows", "java"),
           :environment            => "development",
           :merb_root              => Dir.pwd,
           :use_mutex              => true,
           :log_delimiter          => " ~ ",
           :log_auto_flush         => false,
           :log_level              => :info,
+          :log_stream             => STDOUT,
           :disabled_components    => [],
           :deferred_actions       => [],
-          :verbose                => false
+          :verbose                => false,
+          :name                   => "merb"
         }
       end
 
@@ -34,6 +37,7 @@ module Merb
       # ==== Examples
       #   Merb::Config.use do |config|
       #     config[:exception_details] = false
+      #     config[:log_stream]        = STDOUT
       #   end
       def use
         @configuration ||= {}
@@ -55,14 +59,14 @@ module Merb
       # ==== Returns
       # Object:: The value of the configuration parameter.
       def [](key)
-        (@configuration||={})[key]
+        (@configuration ||= setup)[key]
       end
 
       # ==== Parameters
       # key<Object>:: The key to set the parameter for.
       # val<Object>:: The value of the parameter.
-      def []=(key,val)
-        @configuration[key] = val
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
       end
 
       # ==== Parameters
@@ -102,6 +106,12 @@ module Merb
       #   Configuration settings to use. These are merged with the defaults.
       def setup(settings = {})
         @configuration = defaults.merge(settings)
+        
+        unless @configuration[:reload_classes]
+          @configuration[:fork_for_class_load] = false
+        end
+        
+        @configuration
       end
 
       # Parses the command line arguments and stores them in the config.
@@ -122,99 +132,166 @@ module Merb
 
           opts.banner = "Usage: merb [uGdcIpPhmailLerkKX] [argument]"
           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
-
-          opts.on("-u", "--user USER", "This flag is for having merb run as a user other than the one currently logged in. Note: if you set this you must also provide a --group option for it to take effect.") do |user|
+          opts.separator '*' * 80
+          opts.separator "If no flags are given, Merb starts in the " \
+            "foreground on port 4000."
+          opts.separator '*' * 80
+
+          opts.on("-u", "--user USER", "This flag is for having merb run " \
+                  "as a user other than the one currently logged in. Note: " \
+                  "if you set this you must also provide a --group option " \
+                  "for it to take effect.") do |user|
             options[:user] = user
           end
 
-          opts.on("-G", "--group GROUP", "This flag is for having merb run as a group other than the one currently logged in. Note: if you set this you must also provide a --user option for it to take effect.") do |group|
+          opts.on("-G", "--group GROUP", "This flag is for having merb run " \
+                  "as a group other than the one currently logged in. Note: " \
+                  "if you set this you must also provide a --user option " \
+                  "for it to take effect.") do |group|
             options[:group] = group
           end
 
-          opts.on("-d", "--daemonize", "This will run a single merb in the background.") do |daemon|
+          opts.on("-d", "--daemonize", "This will run a single merb in the " \
+                  "background.") do |daemon|
             options[:daemonize] = true
           end
+          
+          opts.on("-N", "--no-daemonize", "This will allow you to run a " \
+                  "cluster in console mode") do |no_daemon|
+            options[:daemonize] = false
+          end
 
-          opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run.") do |nodes|
+          opts.on("-c", "--cluster-nodes NUM_MERBS", Integer, 
+                  "Number of merb daemons to run.") do |nodes|
+            options[:daemonize] = true unless options.key?(:daemonize)
             options[:cluster] = nodes
           end
 
-          opts.on("-I", "--init-file FILE", "File to use for initialization on load, defaults to config/init.rb") 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
 
-          opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
+          opts.on("-p", "--port PORTNUM", Integer, "Port to run merb on, " \
+                  "defaults to 4000.") do |port|
             options[:port] = port
           end
 
-          opts.on("-o", "--socket-file FILE", "Socket file to run merb on, defaults to [Merb.root]/log/merb.sock") do |port|
+          opts.on("-o", "--socket-file FILE", "Socket file to run merb on, " \
+                  "defaults to [Merb.root]/log/merb.sock. This is for " \
+                  "web servers, like thin, that use sockets." \
+                  "Specify this *only* if you *must*.") do |port|
             options[:socket_file] = port
           end
 
-          opts.on("-s", "--socket SOCKNUM", "Socket number to run merb on, defaults to 0.") do |port|
+          opts.on("-s", "--socket SOCKNUM", Integer, "Socket number to run " \
+                  "merb on, defaults to 0.") do |port|
             options[:socket] = port
           end
 
-          opts.on("-P", "--pid PIDFILE", "PID file, defaults to [Merb.root]/log/merb.[port_number].pid") do |pid_file|
+          opts.on("-n", "--name NAME", String, "Set the name of the application. "\
+                  "This is used in the process title and log file names.") do |name|
+            options[:name] = name
+          end
+
+          opts.on("-P", "--pid PIDFILE", "PID file, defaults to " \
+                  "[Merb.root]/log/merb.main.pid for the master process and" \
+                  "[Merb.root]/log/merb.[port number].pid for worker " \
+                  "processes. For clusters, use %s to specify where " \
+                  "in the file merb should place the port number. For " \
+                  "instance: -P myapp.%s.pid") do |pid_file|
             options[:pid_file] = pid_file
           end
 
-          opts.on("-h", "--host HOSTNAME", "Host to bind to (default is 0.0.0.0).") do |host|
+          opts.on("-h", "--host HOSTNAME", "Host to bind to " \
+                  "(default is 0.0.0.0).") do |host|
             options[:host] = host
           end
 
-          opts.on("-m", "--merb-root /path/to/approot", "The path to the Merb.root for the app you want to run (default is current working dir).") do |root|
+          opts.on("-m", "--merb-root /path/to/approot", "The path to the " \
+                  "Merb.root for the app you want to run " \
+                  "(default is current working directory).") do |root|
             options[:merb_root] = File.expand_path(root)
           end
 
-          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
+          adapters = [:mongrel, :emongrel, :thin, :ebb, :fastcgi, :webrick]
+
+          opts.on("-a", "--adapter ADAPTER",
+                  "The rack adapter to use to run merb (default is mongrel)" \
+                  "[#{adapters.join(', ')}]") do |adapter|
+            options[:adapter] ||= adapter
           end
 
-          opts.on("-R", "--rackup FILE", "Load an alternate Rack config file (default is config/rack.rb)") do |rackup|
+          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|
+          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|
+          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
 
-          opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of these options: debug < info < warn < error < fatal") do |log_level|
+          opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of " \
+                  "these options: debug < info < warn < error < " \
+                  "fatal (default is info)") do |log_level|
             options[:log_level] = log_level.to_sym
+            options[:force_logging] = true
           end
 
-          opts.on("-L", "--log LOGFILE", "A string representing the logfile to use.") do |log_file|
+          opts.on("-L", "--log LOGFILE", "A string representing the logfile to " \
+                  "use. Defaults to [Merb.root]/log/merb.[main].log for the " \
+                  "master process and [Merb.root]/log/merb[port number].log" \
+                  "for worker processes") do |log_file|
             options[:log_file] = log_file
+            options[:force_logging] = true
           end
 
-          opts.on("-e", "--environment STRING", "Run merb in the correct mode(development, production, testing)") do |env|
+          opts.on("-e", "--environment STRING", "Environment to run Merb " \
+                  "under [development, production, testing] " \
+                  "(default is development)") do |env|
             options[:environment] = env
           end
 
           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|
+                  "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|
+          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|
             options[:action] = :kill
+            ports = "main" if ports == "all"
             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|
+          opts.on("-k", "--kill PORT", "Force kill one merb worker " \
+                  "by port number. This will cause the worker to" \
+                  "be respawned. If you want to kill ") do |port|
             options[:action] = :kill_9
+            port = "main" if port == "all"
             options[:port] = port
           end
+          
+          opts.on("--fast-deploy", "Reload the code, but not your" \
+            "init.rb or gems") do
+              options[:action] = :fast_deploy
+          end
 
-          opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
+          # @todo Do we really need this flag? It seems unlikely to want to
+          #   change the mutex from the command-line.
+          opts.on("-X", "--mutex on/off", "This flag is for turning the " \
+                  "mutex lock on and off.") do |mutex|
             if mutex == "off"
               options[:use_mutex] = false
             else
@@ -226,10 +303,13 @@ module Merb
             begin
               require "ruby-debug"
               Debugger.start
-              Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+              if Debugger.respond_to?(:settings)
+                Debugger.settings[:autoeval] = true
+              end
               puts "Debugger enabled"
             rescue LoadError
-              puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+              puts "You need to install ruby-debug to run the server in " \
+                "debugging mode. With gems, use `gem install ruby-debug'"
               exit
             end
           end
@@ -249,7 +329,11 @@ module Merb
         end
 
         # Parse what we have on the command line
-        opts.parse!(argv)
+        begin
+          opts.parse!(argv)
+        rescue OptionParser::InvalidOption => e
+          Merb.fatal! e.message, e
+        end
         Merb::Config.setup(options)
       end
 
@@ -266,6 +350,7 @@ module Merb
       #   Merb::Config.configure do
       #     environment "development"
       #     log_level   "debug"
+      #     log_file    Merb.root / "log" / "special.log"
       #   end
       def configure(&block)
         ConfigBlock.new(self, &block) if block_given?

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

@@ -227,7 +227,6 @@ class Merb::AbstractController
   def initialize(*args)
     @_benchmarks = {}
     @_caught_content = {}
-    @_template_stack = []
   end
   
   # This will dispatch the request, calling internal before/after dispatch_callbacks
@@ -430,7 +429,8 @@ class Merb::AbstractController
   # ====
   # TODO: Update this documentation
   def url(name, *args)
-    request.generate_url(name, *args)
+    args << {}
+    Merb::Router.url(name, *args)
   end
   
   alias_method :relative_url, :url
@@ -451,20 +451,71 @@ class Merb::AbstractController
   # ==== Alternatives
   # If a hash is used as the first argument, a default route will be
   # generated based on it and rparams.
-  def absolute_url(name, rparams={})
-    request.generate_absolute_url(name,rparams)
+  def absolute_url(name, *args)
+    # FIXME: arrgh, why request.protocol returns http://?
+    # :// is not part of protocol name
+    options  = extract_options_from_args!(args) || {}
+    protocol = options.delete(:protocol)
+    host     = options.delete(:host)
+    
+    raise ArgumentError, "The :protocol option must be specified" unless protocol
+    raise ArgumentError, "The :host option must be specified"     unless host
+    
+    args << options
+    
+    protocol + "://" + host + url(name, *args)
+  end
+  
+  # Generates a URL for a single or nested resource.
+  #
+  # ==== Parameters
+  # resources<Symbol,Object>:: The resources for which the URL
+  #   should be generated. These resources should be specified
+  #   in the router.rb file using #resources and #resource.
+  #
+  # options<Hash>:: Any extra parameters that are needed to
+  #   generate the URL.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Examples
+  #
+  # Merb::Router.prepare do
+  #   resources :users do
+  #     resources :comments
+  #   end
+  # end
+  #
+  # resource(:users)            # => /users
+  # resource(@user)             # => /users/10
+  # resource(@user, :comments)  # => /users/10/comments
+  # resource(@user, @comment)   # => /users/10/comments/15
+  # resource(:users, :new)      # => /users/new
+  # resource(:@user, :edit)     # => /users/10/edit
+  #
+  def resource(*args)
+    args << params
+    Merb::Router.resource(*args)
   end
 
   # Calls the capture method for the selected template engine.
   #
   # ==== Parameters
   # *args:: Arguments to pass to the block.
-  # &block:: The template block to call.
+  # &block:: The block to call.
   #
   # ==== Returns
-  # String:: The output of the block.
+  # String:: The output of a template block or the return value of a non-template block converted to a string.
   def capture(*args, &block)
-    send("capture_#{@_engine}", *args, &block)
+    ret = nil
+
+    captured = send("capture_#{@_engine}", *args) do |*args|
+      ret = yield *args
+    end
+
+    # return captured value only if it is not empty
+    captured.empty? ? ret.to_s : captured
   end
 
   # Calls the concatenate method for the selected template engine.
@@ -554,15 +605,4 @@ class Merb::AbstractController
     opts[:exclude]  = Array(opts[:exclude]).map {|x| x.to_s} if opts[:exclude]
     return opts
   end
-
-  # Attempts to return the partial local variable corresponding to sym.
-  #
-  # ==== Paramteres
-  # sym<Symbol>:: Method name.
-  # *arg:: Arguments to pass to the method.
-  # &blk:: A block to pass to the method.
-  def method_missing(sym, *args, &blk)
-    return @_merb_partial_locals[sym] if @_merb_partial_locals && @_merb_partial_locals.key?(sym)
-    super
-  end  
 end

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

@@ -278,6 +278,8 @@ module Merb
 
     class ServerError                   < Merb::ControllerExceptions::Base; end
 
+      class InternalServerError         < Merb::ControllerExceptions::ServerError; self.status = 500; end
+
       class NotImplemented              < Merb::ControllerExceptions::ServerError; self.status = 501; end
 
       class BadGateway                  < Merb::ControllerExceptions::ServerError; self.status = 502; end
@@ -287,21 +289,6 @@ module Merb
       class GatewayTimeout              < Merb::ControllerExceptions::ServerError; self.status = 504; end
 
       class HTTPVersionNotSupported     < Merb::ControllerExceptions::ServerError; self.status = 505; end
-
-      class InternalServerError         < Merb::ControllerExceptions::ServerError #:doc: 
-        self.status = 500;
-        def initialize(exception = nil)
-          @exception = exception
-        end
-
-        def backtrace
-          @exception ? @exception.backtrace : backtrace
-        end
-
-        def message
-          @exception ? @exception.message : message
-        end
-      end
   end
   
   # Required to show exceptions in the log file

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

@@ -218,6 +218,33 @@ class Merb::Controller < Merb::AbstractController
   # ==== Returns
   # Hash:: The parameters from the request object
   def params()  request.params  end
+    
+  # ==== Parameters
+  # name<~to_sym, Hash>:: The name of the URL to generate.
+  # rparams<Hash>:: Parameters for the route generation.
+  #
+  # ==== Returns
+  # String:: The generated URL.
+  #
+  # ==== Alternatives
+  # If a hash is used as the first argument, a default route will be
+  # generated based on it and rparams.
+  # ====
+  # TODO: Update this documentation
+  def url(name, *args)
+    args << params
+    Merb::Router.url(name, *args)
+  end
+
+  alias_method :relative_url, :url
+  
+  def absolute_url(*args)
+    options  = extract_options_from_args!(args) || {}
+    options[:protocol] ||= request.protocol
+    options[:host] ||= request.host
+    args << options
+    super(args.first, *args[1..-1])
+  end
 
   # The results of the controller's render, to be returned to Rack.
   #
@@ -225,7 +252,7 @@ class Merb::Controller < Merb::AbstractController
   # Array[Integer, Hash, String]::
   #   The controller's status code, headers, and body
   def rack_response
-    [status, headers, body]
+    [status, headers, Merb::Rack::StreamWrapper.new(body)]
   end
 
   # Sets a controller to be "abstract"