logging 0.2.0 → 0.3.0

data/lib/logging/appenders/console.rb

@@ -1,4 +1,4 @@
-# $Id: console.rb 17 2007-01-20 18:47:43Z tim_pease $
+# $Id: console.rb 26 2007-01-31 23:19:40Z tim_pease $
 
 require 'logging/appenders/io'
 
@@ -12,10 +12,10 @@ module Appenders
 
     #
     # call-seq:
-    #    StdOut.new
-    #    StdOut.new( :layout => layout )
+    #    Stdout.new
+    #    Stdout.new( :layout => layout )
     #
-    # Creates a new StdOut Appender. The name 'stdout' will always be used for
+    # Creates a new Stdout Appender. The name 'stdout' will always be used for
     # this appender.
     #
     def initialize( name = nil, opts = {} )
@@ -32,10 +32,10 @@ module Appenders
 
     #
     # call-seq:
-    #    StdErr.new
-    #    StdErr.new( :layout => layout )
+    #    Stderr.new
+    #    Stderr.new( :layout => layout )
     #
-    # Creates a new StdErr Appender. The name 'stderr' will always be used for
+    # Creates a new Stderr Appender. The name 'stderr' will always be used for
     # this appender.
     #
     def initialize( name = nil, opts = {} )

data/lib/logging/appenders/file.rb

@@ -1,4 +1,4 @@
-# $Id: file.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: file.rb 27 2007-02-01 16:58:11Z tim_pease $
 
 require 'logging/appenders/io'
 
@@ -30,12 +30,12 @@ module Logging::Appenders
 
       if ::File.exist?(@fn)
         if not ::File.file?(@fn)
-          raise StandardError, "#{@fn} is not a regular file"
+          raise ArgumentError, "#{@fn} is not a regular file"
         elsif not ::File.writable?(@fn)
-          raise StandardError, "#{@fn} is not writeable"
+          raise ArgumentError, "#{@fn} is not writeable"
         end
       elsif not ::File.writable?(::File.dirname(@fn))
-        raise StandardError, "#{::File.dirname(@fn)} is not writable"
+        raise ArgumentError, "#{::File.dirname(@fn)} is not writable"
       end
 
       super(name, ::File.new(@fn, mode), opts)

data/lib/logging/appenders/rolling_file.rb

@@ -1,4 +1,4 @@
-# $Id: rolling_file.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: rolling_file.rb 27 2007-02-01 16:58:11Z tim_pease $
 
 require 'logging/appenders/file'
 
@@ -21,10 +21,10 @@ module Logging::Appenders
   #    /var/log/ruby.log   =>   /var/log/ruby.1.log
   #
   # New log messages will be appended to a newly opened log file of the same
-  # name (<tt>/var/log/ruby.log</tt> in our example above). The age number for
-  # all older log files is incremented when the log file is rolled. The number
-  # of older log files to keep can be given, otherwise all the log files are
-  # kept.
+  # name (<tt>/var/log/ruby.log</tt> in our example above). The age number
+  # for all older log files is incremented when the log file is rolled. The
+  # number of older log files to keep can be given, otherwise all the log
+  # files are kept.
   #
   # The actual process of rolling all the log file names can be expensive if
   # there are many, many older log files to process.

data/lib/logging/appenders/static_appender.rb

@@ -1,4 +1,4 @@
-# $Id: static_appender.rb 12 2007-01-14 20:03:40Z tim_pease $
+# $Id: static_appender.rb 26 2007-01-31 23:19:40Z tim_pease $
 
 require 'logging/appenders/console'
 
@@ -31,25 +31,25 @@ class Appender
     # call-seq:
     #    Appender.stdout
     #
-    # Returns an instance of the StdOut Appender. Unless the user explicitly
-    # creates a new StdOut Appender, the instance returned by this method
+    # Returns an instance of the Stdout Appender. Unless the user explicitly
+    # creates a new Stdout Appender, the instance returned by this method
     # will always be the same:
     #
     #    Appender.stdout.object_id == Appender.stdout.object_id    #=> true
     #
-    def stdout( ) self['stdout'] || ::Logging::Appenders::StdOut.new end
+    def stdout( ) self['stdout'] || ::Logging::Appenders::Stdout.new end
 
     #
     # call-seq:
     #    Appender.stderr
     #
-    # Returns an instance of the StdErr Appender. Unless the user explicitly
-    # creates a new StdErr Appender, the instance returned by this method
+    # Returns an instance of the Stderr Appender. Unless the user explicitly
+    # creates a new Stderr Appender, the instance returned by this method
     # will always be the same:
     #
     #    Appender.stderr.object_id == Appender.stderr.object_id    #=> true
     #
-    def stderr( ) self['stderr'] || ::Logging::Appenders::StdErr.new end
+    def stderr( ) self['stderr'] || ::Logging::Appenders::Stderr.new end
 
   end  # class << self
 end  # class Appender

data/lib/logging/layouts/basic.rb

@@ -1,4 +1,4 @@
-# $Id: basic.rb 15 2007-01-15 19:03:45Z tim_pease $
+# $Id: basic.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'logging'
 require 'logging/layout'
@@ -29,16 +29,9 @@ module Layouts
     # class documentation for details about the formatting used.
     #
     def format( event )
-      start = sprintf("%*s  %s : ", ::Logging::MAX_LEVEL_LENGTH,
-                      ::Logging::LNAMES[event.level], event.logger)
-      buf = ''
-      event.data.each do |obj|
-        buf << start
-        buf << format_obj(obj)
-        buf << "\n"
-      end
-
-      return buf
+      obj = format_obj(event.data)
+      sprintf("%*s  %s : %s\n", ::Logging::MAX_LEVEL_LENGTH,
+              ::Logging::LNAMES[event.level], event.logger, obj)
     end
 
   end  # class Basic

data/lib/logging/layouts/pattern.rb

@@ -1,4 +1,4 @@
-# $Id: pattern.rb 17 2007-01-20 18:47:43Z tim_pease $
+# $Id: pattern.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'logging'
 require 'logging/layout'
@@ -125,7 +125,7 @@ module Layouts
       'F' => 'event.file',
       'l' => '::Logging::LNAMES[event.level]',
       'L' => 'event.line',
-      'm' => :placeholder,
+      'm' => 'format_obj(event.data)',
       'M' => 'event.method',
       'p' => 'Process.pid',
       'r' => 'Integer((Time.now-@created_at)*1000).to_s',
@@ -164,21 +164,17 @@ module Layouts
 
     #
     # call-seq:
-    #    Pattern.create_format_methods( pf )
+    #    Pattern.create_format_method( pf )
     #
-    # This method will create the +format+ and +format_str+ methods in the
-    # given Pattern Layout _pf_ based on the configured format pattern
-    # specified by the user.
+    # This method will create the +format+ method in the given Pattern
+    # Layout _pf_ based on the configured format pattern specified by the
+    # user.
     #
-    def self.create_format_methods( pf )
-      # Create the format_str(event) method. This method will return format
-      # string that can be used with +sprintf+ to format the data objects in
-      # the given _event_.
-      code = "undef :format_str if method_defined? :format_str\n"
-      code << "def format_str( event )\nsprintf(\""
+    def self.create_format_method( pf )
+      # Create the format(event) method
+      code = "undef :format if method_defined? :format\n"
+      code << "def format( event )\nsprintf(\""
       pattern = pf.pattern.dup
-      have_m_directive = false
-      have_percent = false
       args = []
 
       while true
@@ -186,12 +182,7 @@ module Layouts
         code << m[1] unless m[1].empty?
 
         case m[3]
-        when '%'
-          code << '%%%%'   # this results in a %% in the format string
-          have_percent = true
-        when 'm'
-          code << '%' + m[2] + 's'
-          have_m_directive = true
+        when '%': code << '%%'
         when *DIRECTIVE_TABLE.keys
           code << m[2] + 's'
           args << DIRECTIVE_TABLE[m[3]]
@@ -209,23 +200,6 @@ module Layouts
       code << ")\n"
       code << "end\n"
 
-      code.gsub!('%%', '%') if have_percent and not have_m_directive
-      pf.meta_eval code
-
-      # Create the format(event) method
-      code = "undef :format if method_defined? :format\n"
-      if have_m_directive
-        code << <<-CODE
-          def format( event )
-            fmt = format_str(event)
-            buf = ''
-            event.data.each {|obj| buf << sprintf(fmt, format_obj(obj))}
-            buf
-          end
-        CODE
-      else
-        code << "alias :format :format_str\n"
-      end
       pf.meta_eval code
     end
     # :startdoc:
@@ -254,7 +228,7 @@ module Layouts
       @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
 
       Pattern.create_date_format_methods(self)
-      Pattern.create_format_methods(self)
+      Pattern.create_format_method(self)
     end
 
     attr_reader :pattern, :date_pattern, :date_method
@@ -267,7 +241,7 @@ module Layouts
     #
     def pattern=( var )
       @pattern = var
-      Pattern.create_format_methods(self)
+      Pattern.create_format_method(self)
     end
 
     #

data/lib/logging/logger.rb

@@ -1,4 +1,4 @@
-# $Id: logger.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: logger.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'thread'
 require 'logging'
@@ -100,14 +100,14 @@ module Logging
           if logger.level > num
             code << <<-CODE
               def #{name}?( ) false end
-              def #{name}( *args ) false end
+              def #{name}( data = nil ) false end
             CODE
           else
             code << <<-CODE
               def #{name}?( ) true end
-              def #{name}( *args )
-                args.push yield if block_given?
-                log_event(::Logging::LogEvent.new(@name, #{num}, args, @trace)) unless args.empty?
+              def #{name}( data = nil )
+                data = yield if block_given?
+                log_event(::Logging::LogEvent.new(@name, #{num}, data, @trace)) unless data.nil?
                 true
               end
             CODE

data/test/appenders/test_file.rb

@@ -1,4 +1,4 @@
-# $Id: test_file.rb 17 2007-01-20 18:47:43Z tim_pease $
+# $Id: test_file.rb 27 2007-02-01 16:58:11Z tim_pease $
 
 require 'test/setup.rb'
 require 'fileutils'
@@ -10,6 +10,7 @@ module TestAppenders
     include LoggingTestCase
 
     TMP = 'tmp'
+    NAME = 'logfile'
 
     def setup
       super
@@ -22,27 +23,28 @@ module TestAppenders
     end
 
     def teardown
+      cleanup
       FileUtils.rm_rf TMP
     end
 
     def test_initialize
       log = File.join(TMP, 'uw_dir', 'file.log')
-      assert_raise(StandardError) do
-        ::Logging::Appenders::File.new(nil, :filename => log)
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.new(NAME, :filename => log)
       end
 
       log = File.join(TMP, 'dir')
-      assert_raise(StandardError) do
-        ::Logging::Appenders::File.new(nil, :filename => log)
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.new(NAME, :filename => log)
       end
 
       log = File.join(TMP, 'uw_file')
-      assert_raise(StandardError) do
-        ::Logging::Appenders::File.new(nil, :filename => log)
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.new(NAME, :filename => log)
       end
 
       log = File.join(TMP, 'file.log')
-      appender = ::Logging::Appenders::File.new 'logfile', 'filename' => log
+      appender = ::Logging::Appenders::File.new NAME, 'filename' => log
       assert_equal 'logfile', appender.name
       appender << "This will be the first line\n"
       appender << "This will be the second line\n"
@@ -52,9 +54,9 @@ module TestAppenders
         assert_equal "This will be the second line\n", file.readline
         assert_raise(EOFError) {file.readline}
       end
-      appender.close
+      cleanup
 
-      appender = ::Logging::Appenders::File.new 'logfile', :filename => log
+      appender = ::Logging::Appenders::File.new NAME, :filename => log
       assert_equal 'logfile', appender.name
       appender << "This will be the third line\n"
       appender.flush
@@ -64,10 +66,10 @@ module TestAppenders
         assert_equal "This will be the third line\n", file.readline
         assert_raise(EOFError) {file.readline}
       end
-      appender.close
+      cleanup
 
-      appender = ::Logging::Appenders::File.new 'logfile', :filename => log,
-                                                           :truncate => true
+      appender = ::Logging::Appenders::File.new NAME, :filename => log,
+                                                      :truncate => true
       assert_equal 'logfile', appender.name
       appender << "The file was truncated\n"
       appender.flush
@@ -75,7 +77,15 @@ module TestAppenders
         assert_equal "The file was truncated\n", file.readline
         assert_raise(EOFError) {file.readline}
       end
-      appender.close
+      cleanup
+    end
+
+    private
+    def cleanup
+      unless ::Logging::Appender[NAME].nil?
+        ::Logging::Appender[NAME].close false
+        ::Logging::Appender[NAME] = nil
+      end
     end
 
   end  # class TestFile

data/test/appenders/test_io.rb

@@ -1,4 +1,4 @@
-# $Id: test_io.rb 15 2007-01-15 19:03:45Z tim_pease $
+# $Id: test_io.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'test/setup.rb'
 require 'stringio'
@@ -21,16 +21,15 @@ module TestAppenders
 
     def test_append
       event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      [[1, 2, 3, 4]], false)
+                                      [1, 2, 3, 4], false)
       @appender.append event
       assert_equal " WARN  TestLogger : <Array> 1234\n", readline
       assert_raise(EOFError) {readline}
 
       event.level = @levels['debug']
-      event.data = ['the big log message', [1, 2, 3, 4]]
+      event.data = 'the big log message'
       @appender.append event
       assert_equal "DEBUG  TestLogger : the big log message\n", readline
-      assert_equal "DEBUG  TestLogger : <Array> 1234\n", readline
       assert_raise(EOFError) {readline}
 
       @appender.close
@@ -40,7 +39,7 @@ module TestAppenders
     def test_append_error
       @sio.close
       event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      [[1, 2, 3, 4]], false)
+                                      [1, 2, 3, 4], false)
       assert_raise(IOError) {@appender.append event}
       assert_equal true, @appender.closed?
     end

data/test/appenders/test_rolling_file.rb

@@ -1,4 +1,4 @@
-# $Id: test_rolling_file.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: test_rolling_file.rb 27 2007-02-01 16:58:11Z tim_pease $
 
 require 'test/setup.rb'
 require 'fileutils'
@@ -10,6 +10,7 @@ module TestAppenders
     include LoggingTestCase
 
     TMP = 'tmp'
+    NAME = 'roller'
 
     def setup
       super
@@ -21,6 +22,7 @@ module TestAppenders
     end
 
     def teardown
+      cleanup
       FileUtils.rm_rf TMP
     end
 
@@ -28,28 +30,28 @@ module TestAppenders
       assert_equal [], Dir.glob(@glob)
 
       # create a new appender
-      ap = ::Logging::Appenders::RollingFile.new('test', :filename => @fn)
+      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
       assert File.exist?(@fn)
       assert_equal 0, File.size(@fn)
 
       ap << "Just a line of text\n"   # 20 bytes
       ap.flush
       assert_equal 20, File.size(@fn)
-      ap.close
+      cleanup
 
       # make sure we append to the current file (not truncate)
-      ap = ::Logging::Appenders::RollingFile.new('test', :filename => @fn)
+      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
       assert_equal [@fn], Dir.glob(@glob)
       assert_equal 20, File.size(@fn)
 
       ap << "Just another line of text\n"   # 26 bytes
       ap.flush
       assert_equal 46, File.size(@fn)
-      ap.close
+      cleanup
 
       # setting the truncate option to true should roll the current log file
       # and create a new one
-      ap = ::Logging::Appenders::RollingFile.new('test',
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
                :filename => @fn, :truncate => true)
 
       log1 = sprintf(@fn_fmt, 1)
@@ -60,7 +62,7 @@ module TestAppenders
       ap << "Some more text in the new file\n"   # 31 bytes
       ap.flush
       assert_equal 31, File.size(@fn)
-      ap.close
+      cleanup
     end
 
     def test_keep
@@ -73,7 +75,7 @@ module TestAppenders
       FileUtils.touch(@fn)
 
       # keep only five files
-      ap = ::Logging::Appenders::RollingFile.new('test',
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
                :filename => @fn, :keep => 5)
 
       # we still have 13 files because we did not truncate the log file,
@@ -88,29 +90,29 @@ module TestAppenders
         name = sprintf(@fn_fmt, cnt)
         assert_equal cnt-1, File.size(name)
       end
-      ap.close
+      cleanup
     end
 
     def test_max_age
       assert_equal [], Dir.glob(@glob)
 
-      ap = ::Logging::Appenders::RollingFile.new('test',
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
                :filename => @fn, :max_age => 1)
 
       ap << "random message\n"
       assert_equal 1, Dir.glob(@glob).length
 
-      sleep 1
+      sleep 1.250
       ap << "another random message\n"
       assert_equal 2, Dir.glob(@glob).length
 
-      ap.close
+      cleanup
     end
 
     def test_max_size
       assert_equal [], Dir.glob(@glob)
 
-      ap = ::Logging::Appenders::RollingFile.new('test',
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
                :filename => @fn, :max_size => 100)
 
       ap << 'X' * 100; ap.flush
@@ -131,7 +133,15 @@ module TestAppenders
       assert_equal 3, Dir.glob(@glob).length
       assert_equal 0, File.size(@fn)
 
-      ap.close
+      cleanup
+    end
+
+    private
+    def cleanup
+      unless ::Logging::Appender[NAME].nil?
+        ::Logging::Appender[NAME].close false
+        ::Logging::Appender[NAME] = nil
+      end
     end
 
   end  # class TestRollingFile

data/test/layouts/test_basic.rb

@@ -1,4 +1,4 @@
-# $Id: test_basic.rb 15 2007-01-15 19:03:45Z tim_pease $
+# $Id: test_basic.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'test/setup.rb'
 
@@ -17,24 +17,21 @@ module TestLayouts
 
     def test_format
       event = ::Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
-                                       ['log message'], false)
+                                       'log message', false)
       assert_equal " INFO  ArrayLogger : log message\n", @layout.format(event)
 
-      event.data = [[1, 2, 3, 4]]
+      event.data = [1, 2, 3, 4]
       assert_equal " INFO  ArrayLogger : <Array> 1234\n", @layout.format(event)
 
       event.level = @levels['debug']
-      event.data = [[1, 2, 3, 4], 'and some message']
-      log =  "DEBUG  ArrayLogger : <Array> 1234\n"
-      log << "DEBUG  ArrayLogger : and some message\n"
+      event.data = 'and another message'
+      log = "DEBUG  ArrayLogger : and another message\n"
       assert_equal log, @layout.format(event)
 
       event.logger = 'Test'
       event.level = @levels['fatal']
-      event.data = [[1, 2, 3, 4], 'and some message', Exception.new]
-      log =  "FATAL  Test : <Array> 1234\n"
-      log << "FATAL  Test : and some message\n"
-      log << "FATAL  Test : <Exception> Exception\n"
+      event.data = Exception.new
+      log = "FATAL  Test : <Exception> Exception\n"
       assert_equal log, @layout.format(event)
     end
 

data/test/layouts/test_pattern.rb

@@ -1,4 +1,4 @@
-# $Id: test_pattern.rb 17 2007-01-20 18:47:43Z tim_pease $
+# $Id: test_pattern.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'test/setup.rb'
 
@@ -60,27 +60,24 @@ module TestLayouts
       fmt = '\[' + @date_fmt + '\] %s -- %s : %s\n'
 
       event = ::Logging::LogEvent.new('ArrayLogger', @levels['info'],
-                                      ['log message'], false)
+                                      'log message', false)
       rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', 'log message'))
       assert_match rgxp, @layout.format(event)
 
-      event.data = [[1, 2, 3, 4]]
+      event.data = [1, 2, 3, 4]
       rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', '<Array> 1234'))
       assert_match rgxp, @layout.format(event)
 
       event.level = @levels['debug']
-      event.data = [[1, 2, 3, 4], 'and some message']
+      event.data = 'and another message'
       rgxp  = Regexp.new(
-                  sprintf(fmt, 'DEBUG', 'ArrayLogger', '<Array> 1234') +
-                  sprintf(fmt, 'DEBUG', 'ArrayLogger', 'and some message'))
+                  sprintf(fmt, 'DEBUG', 'ArrayLogger', 'and another message'))
       assert_match rgxp, @layout.format(event)
 
       event.logger = 'Test'
       event.level = @levels['fatal']
-      event.data = [[1, 2, 3, 4], 'and some message', Exception.new]
+      event.data = Exception.new
       rgxp  = Regexp.new(
-                  sprintf(fmt, 'FATAL', 'Test', '<Array> 1234') +
-                  sprintf(fmt, 'FATAL', 'Test', 'and some message') +
                   sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
       assert_match rgxp, @layout.format(event)
     end
@@ -105,7 +102,7 @@ module TestLayouts
 
     def test_pattern_all
       event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
-                                      ['log message'], false)
+                                      'log message', false)
       event.instance_variable_set :@file, 'test_file.rb'
       event.instance_variable_set :@line, '123'
       event.instance_variable_set :@method, 'method_name'
@@ -161,7 +158,7 @@ module TestLayouts
       @layout.pattern = '%7.7m'
       assert_equal 'log mes', @layout.format(event)
 
-      event.data = ['tim']
+      event.data = 'tim'
       assert_equal '    tim', @layout.format(event)
 
       @layout.pattern = '%-7.7m'

data/test/test_appender.rb

@@ -1,4 +1,4 @@
-# $Id: test_appender.rb 15 2007-01-15 19:03:45Z tim_pease $
+# $Id: test_appender.rb 26 2007-01-31 23:19:40Z tim_pease $
 
 require 'test/setup.rb'
 
@@ -13,7 +13,7 @@ module TestLogging
       ::Logging.define_levels %w(debug info warn error fatal)
       @levels = ::Logging::LEVELS
       @event = ::Logging::LogEvent.new('logger', @levels['debug'],
-                                       ['message'], false)
+                                       'message', false)
       @appender = ::Logging::Appender.new 'test_appender'
     end
 
@@ -37,6 +37,20 @@ module TestLogging
       assert_raise(RuntimeError) {@appender.append @event}
     end
 
+    def test_class_stderr
+      stderr = ::Logging::Appender.stderr
+      assert_instance_of ::Logging::Appenders::Stderr, stderr
+      assert_equal 'stderr', stderr.name
+      assert_same stderr, ::Logging::Appender.stderr
+    end
+
+    def test_class_stdout
+      stdout = ::Logging::Appender.stdout
+      assert_instance_of ::Logging::Appenders::Stdout, stdout
+      assert_equal 'stdout', stdout.name
+      assert_same stdout, ::Logging::Appender.stdout
+    end
+
     def test_close
       assert_equal false, @appender.closed?
 

data/test/test_log_event.rb

@@ -1,4 +1,4 @@
-# $Id: test_log_event.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: test_log_event.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'test/setup.rb'
 
@@ -14,17 +14,17 @@ module TestLogging
       @logger = ::Logging::Logger['TestLogger']
       @logger.add @appender
 
-      @logger.info 'message 1', %w(a b c)
+      @logger.info 'message 1'
       @event = @appender.event
     end
 
     def test_data
-      assert_equal ['message 1', %w(a b c)], @event.data
+      assert_equal 'message 1', @event.data
     end
 
     def test_data_eq
-      @event.data = ['message 2']
-      assert_equal ['message 2'], @event.data
+      @event.data = 'message 2'
+      assert_equal 'message 2', @event.data
     end
 
     def test_file

data/test/test_logger.rb

@@ -1,4 +1,4 @@
-# $Id: test_logger.rb 22 2007-01-29 16:20:54Z tim_pease $
+# $Id: test_logger.rb 25 2007-01-30 20:19:12Z tim_pease $
 
 require 'test/setup.rb'
 require 'stringio'
@@ -286,8 +286,7 @@ module TestLogging
       assert_nil a1.readline
       assert_nil a2.readline
 
-      log.warn 'this is a warning', [1,2,3,4]
-      assert_equal " WARN  A Logger : this is a warning\n", a1.readline
+      log.warn [1,2,3,4]
       assert_equal " WARN  A Logger : <Array> 1234\n", a1.readline
       assert_nil a1.readline
       assert_nil a2.readline

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.1
 specification_version: 1
 name: logging
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2007-01-29 00:00:00 -07:00
+  version: 0.3.0
+date: 2007-02-01 00:00:00 -07:00
 summary: A flexible and extendable logging library for Ruby.
 require_paths: 
 - lib