0
@@ -278,11 +278,7 @@ module Merb
0
 
0
     # Logger settings
0
     def logger
0
-      Thread.current[:merb_logger] ||= Merb::Logger.new(
0
-        Merb::Config[:log_stream],
0
-        Merb::Config[:log_level],
0
-        Merb::Config[:log_delimiter],
0
-        Merb::Config[:log_auto_flush])
0
+      Thread.current[:merb_logger] ||= Merb::Logger.new
0
     end
0
 
0
     def reset_logger!

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

0
@@ -21,14 +21,6 @@ end
0
 
0
 describe Merb::Logger do
0
 
0
-  describe "Levels" do
0
-    it "should have the same entries as Extlib::Logger::Levels" do
0
-      Extlib::Logger::Levels.each do |level, value|
0
-        Merb::Logger::Levels[level].should == value
0
-      end
0
-    end
0
-  end
0
-
0
   describe "#new" do
0
     it "should call set_log with the arguments it was passed." do
0
       logger = Merb::Logger.allocate # create an object sans initialization
0
@@ -49,12 +41,6 @@ describe Merb::Logger do
0
       Merb.logger.level.should == 4
0
     end
0
 
0
-    it "should set the log level to a specific numeric value when that value is set into Mer" do
0
-      Merb::Config[:log_level] = 5
0
-      Merb.reset_logger!
0
-      Merb.logger.level.should == 5
0
-    end
0
-
0
     it "should set the log level to :debug (0) when Merb.environment is development" do
0
       Merb.environment = "development"
0
       Merb::Config.delete(:log_level)
0
@@ -294,81 +280,4 @@ describe Merb::Logger do
0
       Merb.logger.should log_with_method(:fatal)
0
     end
0
   end # #fatal
0
-  
0
-  describe "#verbose" do
0
-    before do
0
-      @stream = Merb::Config[:log_stream] = StringIO.new
0
-      Merb.reset_logger!
0
-    end
0
-    
0
-    describe "when Merb::Config[:verbose] is false" do
0
-      it "should not log any messages" do
0
-        Merb::Config[:verbose] = false
0
-        Merb::Config[:log_level] = :debug
0
-        Merb.logger.verbose("message", :fatal)
0
-        Merb.logger.flush
0
-        
0
-        Merb.logger.log.string.should_not include("message")
0
-      end
0
-    end
0
-    
0
-    describe "when Merb::Config[:verbose] is true" do
0
-      before do
0
-        Merb::Config[:verbose] = true
0
-        Merb::Config[:log_level] = :debug
0
-      end
0
-
0
-      it "adds to the buffer with error level" do
0
-        set_level(:error)
0
-        Merb.logger.verbose("message", :error)
0
-        Merb.logger.flush
0
-        Merb.logger.log.string.should include("message")
0
-      end
0
-
0
-      it "adds to the buffer with fatal level" do
0
-        set_level(:fatal)
0
-        Merb.logger.verbose("message", :error)
0
-        Merb.logger.flush
0
-        Merb.logger.log.string.should_not include("message")
0
-      end
0
-      
0
-    end
0
-  end
0
-  
0
-  describe "#verbose!" do
0
-    before do
0
-      @stream = Merb::Config[:log_stream] = StringIO.new
0
-      Merb.reset_logger!
0
-    end
0
-    
0
-    describe "when Merb::Config[:verbose] is false" do
0
-      it "should not log any messages" do
0
-        Merb::Config[:verbose] = false
0
-        Merb::Config[:log_level] = :debug
0
-        Merb.logger.verbose!("message", :fatal)
0
-        Merb.logger.log.string.should_not include("message")
0
-      end
0
-    end
0
-    
0
-    describe "when Merb::Config[:verbose] is true" do
0
-      before do
0
-        Merb::Config[:verbose] = true
0
-        Merb::Config[:log_level] = :debug
0
-      end
0
-
0
-      it "adds to the buffer with error level" do
0
-        set_level(:error)
0
-        Merb.logger.verbose!("message", :error)
0
-        Merb.logger.log.string.should include("message")
0
-      end
0
-
0
-      it "adds to the buffer with fatal level" do
0
-        set_level(:fatal)
0
-        Merb.logger.verbose!("message", :error)
0
-        Merb.logger.log.string.should_not include("message")
0
-      end
0
-      
0
-    end
0
-  end
0
-  
0
 end # Merb::Logger