@@ -97,8 +97,6 @@ class Merb::Controller < Merb::AbstractController params end - private - # All methods that are callable as actions. # # ==== Returns lib/merb-core/controller/merb_controller.rb @@ -1,5 +1,16 @@ # 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: @@ -34,37 +45,168 @@ # Merb::Logger.new(log{String, IO},level{Symbol, String}) module Merb - class Logger < Extlib::Logger + 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 = {} - # Appends a message to the log if the specified log level is at least as high as - # the log level of the logger if Merb::Config[:verbose]. Then flushes the log - # buffer to disk. + private + + # Readies a log for writing. # # ==== Parameters - # message<String>:: The message to be logged. - # level<Symbol>:: The level at which to log. Default is :warn. + # log<IO, String>:: Either an IO object or a name of a logfile. + def initialize_log(log) + close if @log # be sure that we don't leave open files laying around. + + if log.respond_to?(:write) + @log = log + elsif File.exist?(log) + @log = open(log, (File::WRONLY | File::APPEND)) + @log.sync = true + else + FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log)) + @log = open(log, (File::WRONLY | File::APPEND | File::CREAT)) + @log.sync = true + @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n") + end + end + + public + + # To initialize the logger you create a new object, proxies to set_log. # - # ==== Returns - # self:: The logger object for chaining. + # ==== 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. # - # @api plugin - def verbose!(message, level = :warn) - send("#{level}!", message) if Merb::Config[:verbose] + # ==== 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 + @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 if the specified log level is at least as high as - # the log level of the logger if Merb::Config[:verbose]. + # 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 - # message<String>:: The message to be logged. - # level<Symbol>:: The level at which to log. Default is :warn. + # string<String>:: The message to be logged. Defaults to nil. # # ==== Returns - # self:: The logger object for chaining. - # - # @api plugin - def verbose(message, level = :warn) - send(level, message) if Merb::Config[:verbose] + # 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 lib/merb-core/logger.rb @@ -21,14 +21,6 @@ end describe Merb::Logger do - describe "Levels" do - it "should have the same entries as Extlib::Logger::Levels" do - Extlib::Logger::Levels.each do |level, value| - Merb::Logger::Levels[level].should == value - end - end - end - describe "#new" do it "should call set_log with the arguments it was passed." do logger = Merb::Logger.allocate # create an object sans initialization @@ -49,12 +41,6 @@ describe Merb::Logger do Merb.logger.level.should == 4 end - it "should set the log level to a specific numeric value when that value is set into Mer" do - Merb::Config[:log_level] = 5 - Merb.reset_logger! - Merb.logger.level.should == 5 - end - it "should set the log level to :debug (0) when Merb.environment is development" do Merb.environment = "development" Merb::Config.delete(:log_level) @@ -294,81 +280,4 @@ describe Merb::Logger do Merb.logger.should log_with_method(:fatal) end end # #fatal - - describe "#verbose" do - before do - @stream = Merb::Config[:log_stream] = StringIO.new - Merb.reset_logger! - end - - describe "when Merb::Config[:verbose] is false" do - it "should not log any messages" do - Merb::Config[:verbose] = false - Merb::Config[:log_level] = :debug - Merb.logger.verbose("message", :fatal) - Merb.logger.flush - - Merb.logger.log.string.should_not include("message") - end - end - - describe "when Merb::Config[:verbose] is true" do - before do - Merb::Config[:verbose] = true - Merb::Config[:log_level] = :debug - end - - it "adds to the buffer with error level" do - set_level(:error) - Merb.logger.verbose("message", :error) - Merb.logger.flush - Merb.logger.log.string.should include("message") - end - - it "adds to the buffer with fatal level" do - set_level(:fatal) - Merb.logger.verbose("message", :error) - Merb.logger.flush - Merb.logger.log.string.should_not include("message") - end - - end - end - - describe "#verbose!" do - before do - @stream = Merb::Config[:log_stream] = StringIO.new - Merb.reset_logger! - end - - describe "when Merb::Config[:verbose] is false" do - it "should not log any messages" do - Merb::Config[:verbose] = false - Merb::Config[:log_level] = :debug - Merb.logger.verbose!("message", :fatal) - Merb.logger.log.string.should_not include("message") - end - end - - describe "when Merb::Config[:verbose] is true" do - before do - Merb::Config[:verbose] = true - Merb::Config[:log_level] = :debug - end - - it "adds to the buffer with error level" do - set_level(:error) - Merb.logger.verbose!("message", :error) - Merb.logger.log.string.should include("message") - end - - it "adds to the buffer with fatal level" do - set_level(:fatal) - Merb.logger.verbose!("message", :error) - Merb.logger.log.string.should_not include("message") - end - - end - end - end # Merb::Logger spec/public/logger/logger_spec.rb @@ -6,7 +6,7 @@ describe "Recognizing requests for deferred routes" do before :each do Merb::Router.prepare do match("/deferred/:zoo").defer_to do |request, params| - route params.merge(:controller => "w00t") if params[:zoo] + params.merge(:controller => "w00t") if params[:zoo] end end end @@ -22,7 +22,7 @@ describe "Recognizing requests for deferred routes" do it "should return the param hash returned by the block" do Merb::Router.prepare do match("/deferred").defer_to do |request, params| - route :hello => "world" + :hello => "world" end end @@ -32,7 +32,7 @@ describe "Recognizing requests for deferred routes" do it "should accept params" do Merb::Router.prepare do match("/").defer_to(:controller => "accounts") do |request, params| - route params.update(:action => "hello") + params.update(:action => "hello") end end @@ -42,7 +42,7 @@ describe "Recognizing requests for deferred routes" do it "should be able to define routes after the deferred route" do Merb::Router.prepare do match("/deferred").defer_to do - route :hello => "world" + :hello => "world" end match("/").to(:foo => "bar") spec/public/router/recognition/deferred_spec.rb 5e4a862e856bd0a5b90deebbf2be3340a8955b6a d425060afd09ba313ae5fba3568029106009abf8 Yehuda Katz wycats@gmail.com http://github.com/wycats/merb-core/commit/a7fb18c7f3cf24321ccd8a8e03f6ddafcb6be651 a7fb18c7f3cf24321ccd8a8e03f6ddafcb6be651 2008-10-11T00:06:01-07:00 2008-10-11T00:06:01-07:00 Merge commit 'adelcambre/sprint' into sprint daf87dba7c130400dbf16edcb8313bc2125537c1 Yehuda Katz wycats@gmail.com