merb-core 0.9.7 → 0.9.8

data/lib/merb-core/bootloader.rb

@@ -6,7 +6,8 @@ module Merb
     #---
     # @semipublic
     cattr_accessor :subclasses, :after_load_callbacks, :before_load_callbacks, :finished
-    self.subclasses, self.after_load_callbacks, self.before_load_callbacks, self.finished = [], [], [], []
+    self.subclasses, self.after_load_callbacks, 
+      self.before_load_callbacks, self.finished = [], [], [], []
 
     class << self
 
@@ -144,13 +145,23 @@ class Merb::BootLoader::Logger < Merb::BootLoader
 
   # Sets Merb.logger to a new logger created based on the config settings.
   def self.run
-    Merb.logger = Merb::Logger.new(Merb.log_file, Merb::Config[:log_level], Merb::Config[:log_delimiter], Merb::Config[:log_auto_flush])
+    Merb::Config[:log_level] ||= begin
+      if Merb.environment == "production"
+        Merb::Logger::Levels[:warn]
+      else
+        Merb::Logger::Levels[:debug]
+      end          
+    end
+    
+    Merb::Config[:log_stream] = Merb.log_stream
+    
     print_warnings
   end
   
   def self.print_warnings
     if Gem::Version.new(Gem::RubyGemsVersion) < Gem::Version.new("1.1")
-      Merb.logger.warn! "Merb requires Rubygems 1.1 and later. Please upgrade RubyGems with gem update --system."
+      Merb.fatal! "Merb requires Rubygems 1.1 and later. " \
+        "Please upgrade RubyGems with gem update --system."
     end
   end
 end
@@ -159,12 +170,12 @@ end
 #
 # Only run if daemonization or clustering options specified on start.
 # Port is taken from Merb::Config and must be already set at this point.
-class Merb::BootLoader::DropPidFile <  Merb::BootLoader
+class Merb::BootLoader::DropPidFile < Merb::BootLoader
   class << self
 
     # Stores a PID file if Merb is running daemonized or clustered.
     def run
-      Merb::Server.store_pid(Merb::Config[:port]) if Merb::Config[:daemonize] || Merb::Config[:cluster]
+      Merb::Server.store_pid("main") #if Merb::Config[:daemonize] || Merb::Config[:cluster]
     end
   end
 end
@@ -257,6 +268,7 @@ class Merb::BootLoader::Dependencies < Merb::BootLoader
   # haven't been loaded up until this point.
 
   def self.run
+    set_encoding
     load_initfile
     load_env_config
     enable_json_gem unless Merb::disabled?(:json)
@@ -265,18 +277,25 @@ class Merb::BootLoader::Dependencies < Merb::BootLoader
   end
 
   def self.load_dependencies
-    dependencies.each { |name, ver| Kernel.load_dependency(name, *ver) }
+    dependencies.each { |dependency| Kernel.load_dependency(dependency) }
   end
 
   def self.enable_json_gem
+    gem "json"
     require "json/ext"
   rescue LoadError
+    gem "json_pure"
     require "json/pure"
   end
 
   def self.update_logger
-    updated_logger_options = [ Merb.log_file, Merb::Config[:log_level], Merb::Config[:log_delimiter], Merb::Config[:log_auto_flush] ]
-    Merb::BootLoader::Logger.run if updated_logger_options != Merb.logger.init_args
+    Merb.logger = nil
+    STDOUT.puts "Logging to #{Merb::Config[:log_file] || 'stdout'}" unless Merb.testing?
+    Merb::Config[:log_stream] = File.open(Merb::Config[:log_file], "w+") if Merb::Config[:log_file]
+  end
+  
+  def self.set_encoding
+    $KCODE = 'UTF8' if $KCODE == 'NONE' || $KCODE.blank?
   end
 
   private
@@ -356,30 +375,172 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
     # Load all classes from Merb's native load paths.
     def run
       # Add models, controllers, helpers and lib to the load path
-      $LOAD_PATH.unshift Merb.dir_for(:model)
-      $LOAD_PATH.unshift Merb.dir_for(:controller)
-      $LOAD_PATH.unshift Merb.dir_for(:lib)
-      $LOAD_PATH.unshift Merb.dir_for(:helper)
+      unless @ran
+        $LOAD_PATH.unshift Merb.dir_for(:model)
+        $LOAD_PATH.unshift Merb.dir_for(:controller)
+        $LOAD_PATH.unshift Merb.dir_for(:lib)
+        $LOAD_PATH.unshift Merb.dir_for(:helper)
+      end
+
+      @ran = true
+      $0 = "merb#{" : " + Merb::Config[:name] if Merb::Config[:name]} : master"
+
+      if Merb::Config[:fork_for_class_load] && !Merb.testing?
+        start_transaction
+      else
+        Merb.trap('INT') do
+          Merb.logger.warn! "Killing children"
+          kill_children
+        end
+      end
 
       # Load application file if it exists - for flat applications
       load_file Merb.dir_for(:application) if File.file?(Merb.dir_for(:application))
       
       # Load classes and their requirements
       Merb.load_paths.each do |component, path|
-        next unless path.last && component != :application
+        next if path.last.blank? || component == :application || component == :router
         load_classes(path.first / path.last)
       end
 
       Merb::Controller.send :include, Merb::GlobalHelpers
     end
     
+    # Wait for any children to exit, remove the "main" PID, and
+    # exit.
+    def exit_gracefully
+      Process.waitall
+      Merb::Server.remove_pid("main")
+      exit
+    end
+
+    # If using fork-based code reloading, set up the BEGIN
+    # point and set up any signals in the parent and child.
+    def start_transaction
+      Merb.logger.warn! "Parent pid: #{Process.pid}"
+      reader, writer = nil, nil
+
+      if GC.respond_to?(:copy_on_write_friendly=)
+        GC.copy_on_write_friendly = true
+      end
+
+      loop do
+        reader, @writer = IO.pipe
+        pid = Kernel.fork
+
+        # pid means we're in the parent; only stay in the loop in that case
+        break unless pid
+        @writer.close
+
+        Merb::Server.store_pid("main")
+
+        if Merb::Config[:console_trap]
+          Merb.trap("INT") {}
+        else
+          Merb.trap("INT") do
+            Merb.logger.warn! "Killing children"
+            begin
+              Process.kill("ABRT", pid)
+            rescue SystemCallError
+            end
+            exit_gracefully
+          end
+        end
+
+        Merb.trap("HUP") do
+          Merb.logger.warn! "Doing a fast deploy\n"
+          Process.kill("HUP", pid)
+        end
+
+        reader_ary = [reader]
+        loop do
+          if exit_status = Process.wait2(pid, Process::WNOHANG)
+            exit_status[1] == 128 ? break : exit
+          end
+          if select(reader_ary, nil, nil, 0.25)
+            begin
+              next if reader.eof?
+              msg = reader.readline
+              if msg =~ /128/
+                break
+              else
+                exit_gracefully
+              end
+            rescue SystemCallError
+              exit_gracefully
+            end
+          end
+        end
+      end
+
+      reader.close
+
+      # add traps to the child
+      if Merb::Config[:console_trap]
+        Merb::Server.add_irb_trap
+        at_exit { kill_children }
+      else
+        Merb.trap('INT') {}
+        Merb.trap('ABRT') { kill_children }
+        Merb.trap('HUP') { kill_children(128) }
+      end
+    end
+
+    # Kill any children of the spawner process and exit with
+    # an appropriate status code.
+    #
+    # Note that exiting the spawner process with a status code
+    # of 128 when a master process exists will cause the
+    # spawner process to be recreated, and the app code reloaded.
+    #
+    # @param status<Integer> The status code to exit with
+    def kill_children(status = 0)
+      Merb.exiting = true unless status == 128
+      
+      begin
+        @writer.puts(status.to_s) if @writer
+      rescue SystemCallError
+      end
+      
+      threads = []
+      
+      ($CHILDREN || []).each do |p|
+        threads << Thread.new do
+          begin
+            Process.kill("ABRT", p)
+            Process.wait2(p)
+          rescue SystemCallError
+          end
+        end
+      end
+      threads.each {|t| t.join }
+      exit(status)
+    end
+    
     # ==== Parameters
     # file<String>:: The file to load.
     def load_file(file)
-      klasses = ObjectSpace.classes.dup
-      load file
-      LOADED_CLASSES[file] = ObjectSpace.classes - klasses
-      MTIMES[file] = File.mtime(file)
+      # Don't do this expensive operation unless we need to
+      unless Merb::Config[:fork_for_class_load]
+        klasses = ObjectSpace.classes.dup
+      end
+      
+      # Ignore the file for syntax errors. The next time
+      # the file is changed, it'll be reloaded again
+      begin
+        load file
+      rescue SyntaxError
+        return
+      ensure
+        if Merb::Config[:reload_classes]
+          MTIMES[file] = File.mtime(file)
+        end
+      end
+      
+      # Don't do this expensive operation unless we need to
+      unless Merb::Config[:fork_for_class_load]
+        LOADED_CLASSES[file] = ObjectSpace.classes - klasses
+      end
     end
     
     # Load classes from given paths - using path/glob pattern.
@@ -403,14 +564,10 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
     # ==== Parameters
     # file<String>:: The file to reload.
     def reload(file)
-      remove_classes_in_file(file) { |f| load_file(f) }
-    end
-    
-    # Reload the router to regenerate all routes.
-    def reload_router!
-      if File.file?(router_file = Merb.dir_for(:router) / Merb.glob_for(:router))
-        Merb::Router.reset!
-        reload router_file
+      if Merb::Config[:fork_for_class_load]
+        kill_children(128)
+      else
+        remove_classes_in_file(file) { |f| load_file(f) }
       end
     end
     
@@ -418,7 +575,7 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
     # file<String>:: The file to remove classes for.
     # &block:: A block to call with the file that has been removed.
     def remove_classes_in_file(file, &block)
-      Merb.klass_hashes.each {|x| x.protect_keys!}
+      Merb.klass_hashes.each { |x| x.protect_keys! }
       if klasses = LOADED_CLASSES.delete(file)
         klasses.each { |klass| remove_constant(klass) unless klass.to_s =~ /Router/ }
       end
@@ -488,10 +645,12 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
         # Stop processing if nothing loads or if everything has loaded
         if klasses.size == size_at_start && klasses.size != 0
           # Write all remaining failed classes and their exceptions to the log
-          error_map.only(*failed_classes).each do |klass, e|
-            Merb.logger.fatal! "Could not load #{klass}:\n\n#{e.message} - (#{e.class})\n\n#{(e.backtrace || []).join("\n")}"
+          messages = error_map.only(*failed_classes).map do |klass, e|
+            ["Could not load #{klass}:\n\n#{e.message} - (#{e.class})", 
+              "#{(e.backtrace || []).join("\n")}"]
           end
-          raise LoadError, "Could not load #{failed_classes.inspect} (see log for details)."
+          messages.each { |msg, trace| Merb.logger.fatal!("#{msg}\n\n#{trace}") }
+          Merb.fatal! "#{failed_classes.join(", ")} failed to load."
         end
         break if(klasses.size == size_at_start || klasses.size == 0)
       end
@@ -501,6 +660,31 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
 
 end
 
+class Merb::BootLoader::Router < Merb::BootLoader
+  class << self
+    
+    def run
+      Merb::BootLoader::LoadClasses.load_file(router_file) if router_file
+    end
+    
+    def reload!
+      if router_file
+        Merb::Router.reset!
+        Merb::BootLoader::LoadClasses.reload(router_file)
+      end
+    end
+    
+    def router_file
+      @router_file ||= begin
+        if File.file?(router = Merb.dir_for(:router) / Merb.glob_for(:router))
+          router
+        end
+      end
+    end
+   
+  end
+end
+
 class Merb::BootLoader::Templates < Merb::BootLoader
   class << self
 
@@ -531,7 +715,9 @@ class Merb::BootLoader::Templates < Merb::BootLoader
       # template roots.  eg app/views/shared/*
       template_paths << Dir["#{Merb.dir_for(:view)}/**/*.#{extension_glob}"] if Merb.dir_for(:view)
 
-      template_paths.flatten.compact.uniq
+      # This ignores templates for partials, which need to be compiled at use time to generate
+      # a preamble that assigns local variables
+      template_paths.flatten.compact.uniq.grep(%r{^.*/[^_][^/]*$})
     end
   end
 end
@@ -618,6 +804,7 @@ class Merb::BootLoader::SetupStubClasses < Merb::BootLoader
     unless defined?(Exceptions)
       Object.class_eval <<-RUBY
         class Application < Merb::Controller
+          abstract!
         end
 
         class Exceptions < Application
@@ -679,7 +866,7 @@ class Merb::BootLoader::ReloadClasses < Merb::BootLoader
       Thread.new do
         loop do
           sleep( seconds )
-          block.call
+          yield
         end
         Thread.exit
       end
@@ -690,36 +877,33 @@ class Merb::BootLoader::ReloadClasses < Merb::BootLoader
   def self.run
     return unless Merb::Config[:reload_classes]
 
-    TimedExecutor.every(Merb::Config[:reload_time] || 0.5) do
-      reload
-    end
-    
-  end
-
-  # Reloads all files.
-  def self.reload
     paths = []
     Merb.load_paths.each do |path_name, file_info|
       path, glob = file_info
       next unless glob
       paths << Dir[path / glob]
     end
+  
+    if Merb.dir_for(:application) && File.file?(Merb.dir_for(:application))
+      paths << Merb.dir_for(:application)
+    end
 
-    paths << Merb.dir_for(:application) if Merb.dir_for(:application) && File.file?(Merb.dir_for(:application))
+    paths.flatten!
 
-    paths.flatten.each do |file|
-      next if Merb::BootLoader::LoadClasses::MTIMES[file] && Merb::BootLoader::LoadClasses::MTIMES[file] == File.mtime(file)
-      Merb::BootLoader::LoadClasses.reload(file)
+    TimedExecutor.every(Merb::Config[:reload_time] || 0.5) do
+      GC.start
+      reload(paths)
     end
+    
   end
-end
-
-class Merb::BootLoader::ReloadTemplates < Merb::BootLoader
 
-  # Reloads all templates if the reload_templates key has been set in config.
-  def self.run
-    unless Merb::Config.key?(:reload_templates)
-      Merb::Config[:reload_templates] = (Merb.environment == "development")
+  # Reloads all files.
+  def self.reload(paths)
+    paths.each do |file|
+      next if LoadClasses::MTIMES[file] &&  
+        LoadClasses::MTIMES[file] == File.mtime(file)
+          
+      LoadClasses.reload(file)
     end
   end
-end
+end

data/lib/merb-core/config.rb

@@ -14,6 +14,7 @@ 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,
@@ -22,7 +23,8 @@ module Merb
           :log_level              => :info,
           :disabled_components    => [],
           :deferred_actions       => [],
-          :verbose                => false
+          :verbose                => false,
+          :name                   => "merb"
         }
       end
 
@@ -55,14 +57,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 +104,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.
@@ -119,103 +127,169 @@ module Merb
         # Build a parser for the command line arguments
         opts = OptionParser.new do |opts|
           opts.version = Merb::VERSION
-          opts.release = Merb::RELEASE
 
           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
@@ -227,10 +301,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
@@ -238,7 +315,11 @@ module Merb
           opts.on("-V", "--verbose", "Print extra information") do
             options[:verbose] = true
           end
-          
+
+          opts.on("-C", "--console-trap", "Enter an irb console on ^C") do
+            options[:console_trap] = true
+          end
+
           opts.on("-?", "-H", "--help", "Show this help message") do
             puts opts
             exit
@@ -246,7 +327,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