merb-core 1.0.15 → 1.1.0.pre

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/logger.rb

@@ -0,0 +1,193 @@
+# Merb::Logger = Extlib::Logger
+
+class Merb::Logger < Extlib::Logger
+  def verbose!(message, level = :warn)
+    send("#{level}!", message) if Merb::Config[:verbose]
+  end
+
+  def verbose(message, level = :warn)
+    send(level, message) if Merb::Config[:verbose]
+  end
+end
+
+# require "time" # httpdate
+# ==== Public Merb Logger API
+#
+# To replace an existing logger with a new one:
+#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Merb.logger.fatal(message<String>,&block)
+#   Merb.logger.error(message<String>,&block)
+#   Merb.logger.warn(message<String>,&block)
+#   Merb.logger.info(message<String>,&block)
+#   Merb.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Merb.logger.fatal!(message<String>,&block)
+#   Merb.logger.error!(message<String>,&block)
+#   Merb.logger.warn!(message<String>,&block)
+#   Merb.logger.info!(message<String>,&block)
+#   Merb.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to
+#   Merb.logger.flush
+#
+# Remove the current log object
+#   Merb.logger.close
+#
+# ==== Private Merb Logger API
+#
+# To initialize the logger you create a new object, proxies to set_log.
+#   Merb::Logger.new(log{String, IO},level{Symbol, String})
+module Merb
+
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :delimiter
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    # ==== Notes
+    # Ruby (standard) logger levels:
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    Levels = Mash.new({
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 0
+    }) unless const_defined?(:Levels)
+
+    @@mutex = {}
+
+    public
+
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Parameters
+    # *args:: Arguments to create the log from. See set_logs for specifics.
+    def initialize(*args)
+      set_log(*args)
+    end
+
+    # Replaces an existing logger with a new one.
+    #
+    # ==== Parameters
+    # log<IO, String>:: Either an IO object or a name of a logfile.
+    # log_level<~to_sym>::
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
+    #   production environment and :debug otherwise.
+    # delimiter<String>::
+    #   Delimiter to use between message sections. Defaults to " ~ ".
+    # auto_flush<Boolean>::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to false.
+    def set_log(stream = Merb::Config[:log_stream],
+      log_level = Merb::Config[:log_level],
+      delimiter = Merb::Config[:log_delimiter],
+      auto_flush = Merb::Config[:log_auto_flush])
+
+      @buffer                   = []
+      @delimiter                = delimiter
+      @auto_flush               = auto_flush
+
+      if Levels[log_level]
+        @level                  = Levels[log_level]
+      else
+        @level                  = log_level
+      end
+
+      @log                      = stream
+      @log.sync                 = true
+      @mutex = (@@mutex[@log] ||= Mutex.new)
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      @mutex.synchronize do
+        @log.write(@buffer.slice!(0..-1).to_s)
+      end
+    end
+
+    # Close and remove the current log object.
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    # ==== Parameters
+    # string<String>:: The message to be logged. Defaults to nil.
+    #
+    # ==== Returns
+    # String:: The resulting message added to the log file.
+    def <<(string = nil)
+      message = ""
+      message << delimiter
+      message << string if string
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+
+      message
+    end
+    alias :push :<<
+
+    # Generate the logging methods for Merb.logger for each log level.
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        self << message if #{number} >= level
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # string<String>:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        self << message if #{number} >= level
+        flush if #{number} >= level
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+  end
+
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/plugins.rb

@@ -0,0 +1,80 @@
+module Merb
+
+  module Plugins
+
+    # Returns the configuration settings hash for plugins. This is prepopulated from
+    # Merb.root / "config/plugins.yml" if it is present.
+    #
+    # ==== Returns
+    # Hash::
+    #   The configuration loaded from Merb.root / "config/plugins.yml" or, if
+    #   the load fails, an empty hash whose default value is another Hash.
+    #
+    # @api plugin
+    def self.config
+      @config ||= begin
+        # this is so you can do Merb.plugins.config[:helpers][:awesome] = "bar"
+        config_hash = Hash.new {|h,k| h[k] = {}}
+        file = Merb.root / "config" / "plugins.yml"
+
+        if File.exists?(file)
+          require 'yaml'
+          to_merge = YAML.load_file(file)
+        else
+          to_merge = {}
+        end
+        
+        config_hash.merge(to_merge)
+      end
+    end
+
+    # ==== Returns
+    # Array(String):: All Rakefile load paths Merb uses for plugins.
+    #
+    # @api plugin
+    def self.rakefiles
+      Merb.rakefiles
+    end
+    
+    # ==== Returns
+    # Array(String):: All Generator load paths Merb uses for plugins.
+    #
+    # @api plugin
+    def self.generators
+      Merb.generators
+    end
+
+    # ==== Parameters
+    # *rakefiles:: Rakefiles to add to the list of plugin Rakefiles.
+    #
+    # ==== Notes
+    #
+    # This is a recommended way to register your plugin's Raketasks
+    # in Merb.
+    #
+    # ==== Examples
+    # From merb_sequel plugin:
+    #
+    # if defined(Merb::Plugins)
+    #   Merb::Plugins.add_rakefiles "merb_sequel" / "merbtasks"
+    # end
+    #
+    # @api plugin
+    def self.add_rakefiles(*rakefiles)
+      Merb.add_rakefiles(*rakefiles)
+    end
+    
+    # ==== Parameters
+    # *generators:: Generator paths to add to the list of plugin generators.
+    #
+    # ==== Notes
+    #
+    # This is the recommended way to register your plugin's generators
+    # in Merb.
+    #
+    # @api plugin
+    def self.add_generators(*generators)
+      Merb.add_generators(*generators)
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/rack/adapter/abstract.rb

@@ -0,0 +1,268 @@
+module Merb
+  module Rack
+    class AbstractAdapter
+
+      # This method is designed to be overridden in a rack adapter.  It 
+      # will be called to start a server created with the new_server method.
+      # This is called from the AbstractAdapter start method.
+      #
+      # @api plugin
+      # @overridable
+      def self.start_server
+        raise NotImplemented
+      end
+      
+      # This method is designed to be overridden in a rack adapter.  It will
+      # be called to create a new instance of the server for the adapter to 
+      # start.  The adapter should attempt to bind to a port at this point. 
+      # This is called from the AbstractAdapter start method.
+      #
+      # ==== Parameters
+      # port<Integer>:: The port the server should listen on
+      #
+      # @api plugin
+      # @overridable
+      def self.new_server(port)
+        raise NotImplemented
+      end
+      
+      # This method is designed to be overridden in a rack adapter.  It will
+      # be called to stop the adapter server.  
+      #
+      # ==== Parameters
+      # status<Integer>:: The exit status the adapter should exit with. 
+      #
+      # ==== Returns
+      # Boolean:: True if the server was properly stopped.  
+      #
+      # @api plugin
+      # @overridable
+      def self.stop(status)
+        raise NotImplemented
+      end
+
+      # Spawn a new worker process at a port.
+      #
+      # ==== Parameters
+      # port<Integer>:: The port to start the worker process on. 
+      #
+      # @api private
+      def self.spawn_worker(port)
+        worker_pid = Kernel.fork
+        start_at_port(port, @opts) unless worker_pid
+
+        # If we have a worker_pid, we're in the parent.
+        throw(:new_worker) unless worker_pid
+
+        @pids[port] = worker_pid
+        $WORKERS = @pids.values
+      end
+
+      # The main start method for bootloaders that support forking.
+      # This method launches the adapters which inherit using the 
+      # new_server and start_server methods.  This method should not
+      # be overridden in adapters which want to fork.  
+      #
+      # ==== Parameters
+      # opts<Hash>:: A hash of options
+      #   socket: the socket to bind to
+      #   port: the port to bind to
+      #   cluster: the number 
+      #
+      # @api private
+      def self.start(opts={})
+        @opts = opts
+        $WORKERS ||= []
+        parent = nil
+
+        @pids = {}
+        port = (opts[:socket] || opts[:port]).to_i
+        max_port = Merb::Config[:cluster] ? Merb::Config[:cluster] - 1 : 0
+
+        # If we only have a single merb, just start it up and dispense with
+        # the spawner/worker setup.
+        if max_port == 0
+          start_at_port(port)
+          return
+        end
+
+        $0 = process_title(:spawner, port)
+
+        # For each port, spawn a new worker. The parent will continue in
+        # the loop, while the worker will throw :new_worker and be booted
+        # out of the loop.
+        catch(:new_worker) do
+          0.upto(max_port) do |i|
+            parent = spawn_worker(port + i)
+          end
+        end
+
+        # If we're in a worker, we're done. Otherwise, we've completed
+        # setting up workers and now need to watch them.
+        return unless parent
+
+        # For each worker, set up a thread in the spawner to watch it
+        0.upto(max_port) do |i|
+          Thread.new do
+            catch(:new_worker) do
+              loop do
+                pid = @pids[port + i]
+                begin
+                  # Watch for the pid to exit.
+                  _, status = Process.wait2(pid)
+
+                  # If the pid doesn't exist, we want to silently exit instead of
+                  # raising here.
+                rescue SystemCallError => e
+                ensure
+                  # If there was no worker with that PID, the status was non-0
+                  # (we send back a status of 128 when ABRT is called on a 
+                  # worker, and Merb.fatal! exits with a status of 1), or if
+                  # Merb is in the process of exiting, *then* don't respawn.
+                  # Note that processes killed with kill -9 will return no
+                  # exitstatus, and we respawn them.
+                  if !status || 
+                    (status.exitstatus && status.exitstatus != 0) || 
+                    Merb.exiting then
+                    Thread.exit
+                  end
+                end
+
+                # Otherwise, respawn the worker, and watch it again.
+                spawn_worker(port + i)
+              end
+            end
+          end
+        end
+
+        # The spawner process will make it here, and when it does, it should just 
+        # sleep so it can pick up ctrl-c if it's in console mode.
+        sleep
+
+      end
+
+      # Fork a server on the specified port and start the app.
+      #
+      # ==== Parameters
+      # port<Integer>:: The port to start the server on
+      # opts<Hash>:: The hash of options, defaults to the @opts 
+      #   instance variable.  
+      #
+      # @api private
+      def self.start_at_port(port, opts = @opts)
+        at_exit do
+          Merb::Server.remove_pid(port)
+        end
+
+        Merb::Worker.start unless Merb.testing?
+
+        # If Merb is daemonized, trap INT. If it's not daemonized,
+        # we let the master process' ctrl-c control the cluster
+        # of workers.
+        if Merb::Config[:daemonize]
+          Merb.trap('INT') do
+            stop
+            Merb.logger.warn! "Exiting port #{port}\n"
+            exit_process
+          end
+          # If it was not fork_for_class_load, we already set up
+          # ctrl-c handlers in the master thread.
+        elsif Merb::Config[:fork_for_class_load]
+          if Merb::Config[:console_trap]
+            Merb::Server.add_irb_trap
+          end
+        end
+
+        # In daemonized mode or not, support HUPing the process to
+        # restart it.
+        Merb.trap('HUP') do
+          Merb.exiting = true
+          stop
+          Merb.logger.warn! "Exiting port #{port} on #{Process.pid}\n"
+          exit_process
+        end
+
+        # ABRTing the process will kill it, and it will not be respawned.
+        Merb.trap('ABRT') do
+          Merb.exiting = true
+          stopped = stop(128)
+          Merb.logger.warn! "Exiting port #{port}\n" if stopped
+          exit_process(128)
+        end
+
+        # Each worker gets its own `ps' name.
+        $0 = process_title(:worker, port)
+
+        # Store the PID for this worker
+        Merb::Server.store_pid(port)
+
+        Merb::Config[:log_delimiter] = "#{process_title(:worker, port)} ~ "
+
+        Merb.reset_logger!
+        Merb.logger.warn!("Starting #{self.name.split("::").last} at port #{port}")
+
+        # If we can't connect to the port, keep trying until we can. Print
+        # a warning about this once. Try every 0.25s.
+        printed_warning = false
+        loop do
+          begin
+            # Call the adapter's new_server method, which should attempt
+            # to bind to a port.
+            new_server(port)
+          rescue Errno::EADDRINUSE
+            unless printed_warning
+              Merb.logger.warn! "Port #{port} is in use, " \
+                "Waiting for it to become available."
+              printed_warning = true
+            end
+
+            sleep 0.25
+            next
+          end
+          break
+        end
+
+        Merb.logger.warn! "Successfully bound to port #{port}"
+
+        Merb::Server.change_privilege
+
+        # Call the adapter's start_server method.
+        start_server
+      end
+
+      # Exit the process with the specified status.  
+      #
+      # ==== Parameters
+      # status<Integer>:: The exit code of the process.
+      # 
+      # @api private
+      def self.exit_process(status = 0)
+        exit(status)
+      end
+
+      # Set the process title.
+      #
+      # ==== Parameters
+      # whoami<Symbol>:: Either :spawner for the master process or :worker for any of the worker
+      #   processes. 
+      # port<Integer>:: The base port that the app is running on. 
+      #
+      # @api private
+      def self.process_title(whoami, port)
+        name = Merb::Config[:name]
+        app  = "merb#{" : #{name}" if (name && name != "merb")}"
+        max_port  = Merb::Config[:cluster] ? (Merb::Config[:cluster] - 1) : 0
+        numbers   = ((whoami != :worker) && (max_port > 0)) ? "#{port}..#{port + max_port}" : port
+        file      = Merb::Config[:socket_file] % port if Merb::Config[:socket_file]
+        
+        listening_on = if Merb::Config[:socket]
+          "socket#{'s' if max_port > 0 && whoami != :worker} #{numbers} "\
+          "#{file ? file : "#{Merb.log_path}/#{name}.#{port}.sock"}"
+        else
+          "port#{'s' if max_port > 0 && whoami != :worker} #{port}"
+        end
+        "#{app} : #{whoami} (#{listening_on})"
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/rack/adapter/ebb.rb

@@ -0,0 +1,24 @@
+require 'ebb'
+module Merb
+  
+  module Rack
+
+    class Ebb < Merb::Rack::AbstractAdapter
+      # start an Ebb server on given host and port.
+      
+      def self.new_server(port)
+        Merb::Dispatcher.use_mutex = false
+        opts = @opts.merge(:port => port)
+        @th = Thread.new { Thread.current[:server] = ::Ebb.start_server(opts[:app], opts) }
+      end
+      
+      def self.start_server
+        @th.join
+      end
+      
+      def self.stop(status = 0)
+        ::Ebb.stop_server
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/rack/adapter/evented_mongrel.rb

@@ -0,0 +1,13 @@
+require 'swiftcore/evented_mongrel'
+require 'merb-core/rack/handler/mongrel'
+module Merb
+  module Rack
+
+    class EventedMongrel < Mongrel
+      def self.new_server(port)
+        Merb::Dispatcher.use_mutex = false
+        super
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/merb-core-0.9.14/lib/merb-core/rack/adapter/fcgi.rb

@@ -0,0 +1,17 @@
+module Merb
+  module Rack
+    
+    class FastCGI
+      # ==== Parameters
+      # opts<Hash>:: Options for FastCGI (see below).
+      #
+      # ==== Options (opts)
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using FastCGI adapter")
+        Merb::Server.change_privilege
+        ::Rack::Handler::FastCGI.run(opts[:app], opts)
+      end
+    end
+  end
+end