logging 0.9.0 → 0.9.1

data/History.txt

@@ -1,4 +1,12 @@
-== 0.9.0 / 2008-07-
+== 0.9.1 / 2008-08-14
+
+1 minor enhancement
+  - added a method to show the logging configuration
+2 bug fixes
+  - checking for sync method on the IO streams before calling
+  - fixed the internal logging levels
+
+== 0.9.0 / 2008-07-16
 
 2 minor enhancement
   - Exceptions from appenders are captured and logged

data/README.txt

@@ -86,7 +86,8 @@ class names.
 
 == REQUIREMENTS
 
-Logging does not depend on any other installed libraries or gems.
+Logging requires the "lockfile" gem to run and the "flexmock" gem to run the
+tests"
 
 == LICENSE
 

data/Rakefile

@@ -1,4 +1,3 @@
-# $Id$
 
 load 'tasks/setup.rb'
 
@@ -17,7 +16,7 @@ PROJ.rdoc.dir = 'doc/rdoc'
 #PROJ.rdoc.remote_dir = 'rdoc'
 PROJ.rdoc.remote_dir = ''
 PROJ.version = Logging::VERSION
-PROJ.release_name = 'Monkeyful Chimptacular'
+PROJ.release_name = %q{Green Eggs & Ham}
 
 PROJ.exclude << %w[^tags$ ^tasks/archive ^coverage]
 PROJ.rdoc.exclude << '^data'

data/lib/logging.rb

@@ -10,12 +10,12 @@ unless defined? Logging
 module Logging
 
   # :stopdoc:
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   WIN32 = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM
   LEVELS = {}
-  LNAMES = {}
+  LNAMES = []
   # :startdoc:
 
   class << self
@@ -192,7 +192,8 @@ module Logging
         end
       end
 
-      longest = names.values.inject {|x,y| (x.length > y.length) ? x : y}
+      longest = names.inject {|x,y| (x.length > y.length) ? x : y}
+      longest = 'off' if longest.length < 3
       module_eval "MAX_LEVEL_LENGTH = #{longest.length}", __FILE__, __LINE__
 
       levels.keys
@@ -258,6 +259,77 @@ module Logging
       Dir.glob(search_me).sort.each {|rb| require rb}
     end
 
+    # call-seq:
+    #    show_configuration( io = STDOUT, logger = 'root' )
+    #
+    # This method is used to show the configuration of the logging
+    # framework. The information is written to the given _io_ stream
+    # (defaulting to stdout). Normally the configuration is dumped starting
+    # with the root logger, but any logger name can be given.
+    #
+    # Each line contains information for a single logger and it's appenders.
+    # A child logger is indented two spaces from it's parent logger. Each
+    # line contains the logger name, level, additivity, and trace settings.
+    # Here is a brief example:
+    #
+    #    root  ...........................   *info      -T
+    #      LoggerA  ......................    info  +A  -T
+    #        LoggerA::LoggerB  ...........    info  +A  -T
+    #        LoggerA::LoggerC  ...........  *debug  +A  -T
+    #      LoggerD  ......................   *warn  -A  +T
+    #
+    # The lines can be deciphered as follows:
+    #
+    #    1) name       - the name of the logger
+    #
+    #    2) level      - the logger level; if it is preceeded by an
+    #                    asterisk then the level was explicitly set for that
+    #                    logger (as opposed to being inherited from the parent
+    #                    logger)
+    #
+    #    3) additivity - a "+A" shows the logger is additive, and log events
+    #                    will be passed up to the parent logger; "-A" shows
+    #                    that the logger will *not* pass log events up to the
+    #                    parent logger
+    #
+    #    4) trace      - a "+T" shows that the logger will include trace
+    #                    information in generated log events (this includes
+    #                    filename and line number of the log message; "-T"
+    #                    shows that the logger does not include trace
+    #                    information in the log events)
+    #
+    # If a logger has appenders then they are listed, on per line,
+    # immediately below the logger. Appender lines are pre-pended with a
+    # single dash:
+    #
+    #    root  ...........................   *info      -T
+    #    - <Appenders::Stdout:0x8b02a4 name="stdout">
+    #      LoggerA  ......................    info  +A  -T
+    #        LoggerA::LoggerB  ...........    info  +A  -T
+    #        LoggerA::LoggerC  ...........  *debug  +A  -T
+    #      LoggerD  ......................   *warn  -A  +T
+    #      - <Appenders::Stderr:0x8b04ca name="stderr">
+    #
+    # We can see in this configuration dump that all the loggers will append
+    # to stdout via the Stdout appender configured in the root logger. All
+    # the loggers are additive, and so their generated log events will be
+    # passed up to the root logger.
+    #
+    # The exception in this configuration is LoggerD. Its additivity is set
+    # to false. It uses its own appender to send messages to stderr.
+    #
+    def show_configuration( io = STDOUT, logger = 'root', indent = 0 )
+      logger = ::Logging::Logger[logger] unless ::Logging::Logger === logger
+
+      logger._dump_configuration(io, indent)
+
+      indent += 2
+      children = ::Logging::Repository.instance.children(logger.name)
+      children.sort {|a,b| a.name <=> b.name}.each do |child|
+        ::Logging.show_configuration(io, child, indent)
+      end
+    end
+
     # :stopdoc:
     # Convert the given level into a connaconical form - a lowercase string.
     def levelify( level )
@@ -275,6 +347,11 @@ module Logging
       when 'off'; LEVELS.length
       else begin; Integer(l); rescue ArgumentError; LEVELS[l] end end
     end
+
+    # Internal logging method for use by the framework.
+    def log_internal( level = 1, &block )
+      ::Logging::Logger[::Logging].__send__(levelify(LNAMES[level]), &block)
+    end
     # :startdoc:
   end
 end  # module Logging

data/lib/logging/appender.rb

@@ -70,8 +70,7 @@ class Appender
 
   end  # class << self
 
-  attr_reader :name, :layout, :level, :log
-  private :log
+  attr_reader :name, :layout, :level
 
   # call-seq:
   #    Appender.new( name )
@@ -82,9 +81,12 @@ class Appender
   # layout will be written to the logging destination when the Appender is
   # created.
   #
+  # Options:
+  #
+  #    :layout   => the layout to use when formatting log events
+  #    :level    => the level at which to log
+  #
   def initialize( name, opts = {} )
-    @log = ::Logging::Logger[self]
-
     @name = name.to_s
     @closed = false
 
@@ -98,7 +100,7 @@ class Appender
       begin 
         sync {write(header)}
       rescue StandardError => err
-        log.error err
+        ::Logging.log_internal(-2) {err}
       end
     end
 
@@ -123,7 +125,7 @@ class Appender
       begin
         sync {write(event)}
       rescue StandardError => err
-        log.error err
+        ::Logging.log_internal(-2) {err}
       end
     end
 
@@ -146,7 +148,7 @@ class Appender
       begin
         sync {write(str)}
       rescue StandardError => err
-        log.error err
+        ::Logging.log_internal(-2) {err}
       end
     end
     self
@@ -225,7 +227,7 @@ class Appender
         begin
           sync {write(footer)}
         rescue StandardError => err
-          log.error err
+          ::Logging.log_internal(-2) {err}
         end
       end
     end
@@ -253,6 +255,19 @@ class Appender
     self
   end
 
+  # call-seq:
+  #     inspect    => string
+  #
+  # Returns a string representation of the appender.
+  #
+  def inspect
+    "<%s:0x%x name=\"%s\">" % [
+        self.class.name.sub(%r/^Logging::/, ''),
+        self.object_id,
+        self.name
+    ]
+  end
+
 
   private 
 

data/lib/logging/appenders/console.rb

@@ -8,14 +8,24 @@ module Logging::Appenders
   class Stdout < ::Logging::Appenders::IO
 
     # call-seq:
-    #    Stdout.new
+    #    Stdout.new( name = 'stdout' )
     #    Stdout.new( :layout => layout )
+    #    Stdout.new( name = 'stdout', :level => 'info' )
     #
-    # Creates a new Stdout Appender. The name 'stdout' will always be used
-    # for this appender.
+    # Creates a new Stdout Appender. The name 'stdout' will be used unless
+    # another is given. Optionally, a layout can be given for the appender
+    # to use (otherwise a basic appender will be created) and a log level
+    # can be specified.
     #
-    def initialize( name = nil, opts = {} )
-      name ||= 'stdout'
+    # Options:
+    #
+    #    :layout   => the layout to use when formatting log events
+    #    :level    => the level at which to log
+    #
+    def initialize( *args )
+      opts = Hash === args.last ? args.pop : {}
+      name = args.empty? ? 'stdout' : args.shift 
+
       super(name, STDOUT, opts)
     end
   end  # class Stdout
@@ -25,14 +35,24 @@ module Logging::Appenders
   class Stderr < ::Logging::Appenders::IO
 
     # call-seq:
-    #    Stderr.new
+    #    Stderr.new( name = 'stderr' )
     #    Stderr.new( :layout => layout )
+    #    Stderr.new( name = 'stderr', :level => 'warn' )
     #
-    # Creates a new Stderr Appender. The name 'stderr' will always be used
-    # for this appender.
+    # Creates a new Stderr Appender. The name 'stderr' will be used unless
+    # another is given. Optionally, a layout can be given for the appender
+    # to use (otherwise a basic appender will be created) and a log level
+    # can be specified.
     #
-    def initialize( name = nil, opts = {} )
-      name ||= 'stderr'
+    # Options:
+    #
+    #    :layout   => the layout to use when formatting log events
+    #    :level    => the level at which to log
+    #
+    def initialize( *args )
+      opts = Hash === args.last ? args.pop : {}
+      name = args.empty? ? 'stderr' : args.shift 
+
       super(name, STDERR, opts)
     end
   end  # class Stderr

data/lib/logging/appenders/email.rb

@@ -117,8 +117,8 @@ class Email < ::Logging::Appender
       Net::SMTP.start(*@params) {|smtp| smtp.sendmail(rfc822msg, @from, @to)}
     rescue StandardError => err
       self.level = :off
-      log.warn 'e-mail notifications have been disabled'
-      log.error err
+      ::Logging.log_internal {'e-mail notifications have been disabled'}
+      ::Logging.log_internal(-2) {err}
     ensure
       @buff.clear
     end

data/lib/logging/appenders/growl.rb

@@ -34,7 +34,7 @@ module Logging::Appenders
       # make sure the growlnotify command can be called
       unless system('growlnotify -v 2>&1 > /dev/null')
         self.level = :off
-        log.warn 'growl notifications have been disabled'
+        ::Logging.log_internal {'growl notifications have been disabled'}
       end
     end
 
@@ -183,7 +183,7 @@ module Logging::Appenders
     def call_growl( *args )
       unless system(@growl % args)
         self.level = :off
-        log.warn 'growl notifications have been disabled'
+        ::Logging.log_internal {'growl notifications have been disabled'}
       end
     end
 

data/lib/logging/appenders/io.rb

@@ -19,7 +19,7 @@ module Logging::Appenders
       end
 
       @io = io
-      @io.sync = true
+      @io.sync = true if @io.respond_to?('sync') rescue nil
       super(name, opts)
     end
 

data/lib/logging/appenders/rolling_file.rb

@@ -162,13 +162,10 @@ module Logging::Appenders
       if roll_required?(str)
         return roll unless @lockfile
 
-        begin
-          @lockfile.lock
+        @lockfile.lock {
           check_logfile
           roll if roll_required?
-        ensure
-          @lockfile.unlock
-        end
+        }
       end
     end
 

data/lib/logging/logger.rb

@@ -432,6 +432,58 @@ module Logging
       @level     = opts.getopt(:level)
       ::Logging::Logger.define_log_methods(self)
     end
+
+    # call-seq:
+    #    _dump_configuration( io = STDOUT, indent = 0 )
+    #
+    # An internal method that is used to dump this logger's configuration to
+    # the given _io_ stream. The configuration includes the logger's name,
+    # level, additivity, and trace settings. The configured appenders are
+    # also printed to the _io_ stream.
+    #
+    def _dump_configuration( io = STDOUT, indent = 0 )
+      str, spacer, base = '', '  ', 50
+      indent_str = indent == 0 ? '' : ' ' * indent
+
+      str << indent_str
+      str << self.name.reduce(base - indent)
+      if (str.length + spacer.length) < base
+        str << spacer
+        str << '.' * (base - str.length)
+      end
+      io.print(str.ljust(base))
+      io.print(spacer)
+
+      level_str  = @level.nil? ? '' : '*'
+      level_str << if level < ::Logging::LEVELS.length
+        ::Logging.levelify(::Logging::LNAMES[level])
+      else
+        'off'
+      end
+      level_len = ::Logging::MAX_LEVEL_LENGTH + 1
+
+      io.print("%#{level_len}s" % level_str)
+      io.print(spacer)
+
+      if self.respond_to?(:additive)
+        io.print(additive ? '+A' : '-A')
+      else
+        io.print('  ')
+      end
+
+      io.print(spacer)
+      io.print(trace ? '+T' : '-T')
+      io.print("\n")
+
+      @appenders.each do |appender|
+        io.print(indent_str)
+        io.print('- ')
+        io.print(appender.inspect)
+        io.print("\n")
+      end
+
+      return io
+    end
     # :startdoc:
 
   end  # class Logger

data/lib/logging/repository.rb

@@ -20,6 +20,7 @@ module Logging
     def initialize
       @h = {:root => ::Logging::RootLogger.new}
 
+      # configures the internal logger which is disabled by default
       logger = ::Logging::Logger.allocate
       logger._setup(
           to_key(::Logging),
@@ -97,9 +98,14 @@ module Logging
     #
     # Returns the parent logger for the logger identified by _key_ where
     # _key_ follows the same identification rules described in
-    # +Repository#[]+. A parent is returned regardless of the
+    # <tt>Repository#[]</tt>. A parent is returned regardless of the
     # existence of the logger referenced by _key_.
     #
+    # A note about parents -
+    #
+    # If you have a class A::B::C, then the parent of C is B, and the parent
+    # of B is A. Parents are determined by namespace.
+    #
     def parent( key )
       return if 'root' == key.to_s
 

data/lib/logging/utils.rb

@@ -40,4 +40,33 @@ class Hash
   end
 end
 
+class String
+
+  # call-seq:
+  #    reduce( width, ellipses = '...' )    #=> string
+  #
+  # Reduce the size of the current string to the given _width_ by remove
+  # characters from the middle of ths tring and replacing them with
+  # _ellipses_. If the _width_ is greater than the length of the string, the
+  # string is returned unchanged. If the _width_ is less than the length of
+  # the _ellipses_, then the _ellipses_ are returned.
+  #
+  def reduce( width, ellipses = '...')
+    raise ArgumentError, "width cannot be negative: #{width}" if width < 0
+
+    return self if length <= width
+
+    remove = length - width + ellipses.length
+    return ellipses.dup if remove >= length
+
+    left_end = (length + 1 - remove) / 2
+    right_start = left_end + remove
+
+    left = self[0,left_end]
+    right = self[right_start,length-right_start]
+
+    left << ellipses << right
+  end
+end
+
 # EOF

data/test/appenders/test_console.rb

@@ -8,6 +8,8 @@ module TestAppenders
     include LoggingTestCase
 
     def test_initialize
+      ::Logging::Repository.instance
+
       appender = ::Logging::Appenders::Stdout.new
       assert_equal 'stdout', appender.name
       assert_same STDOUT, appender.instance_variable_get(:@io)
@@ -15,13 +17,27 @@ module TestAppenders
       appender.close
       assert_equal true, appender.closed?
       assert_equal false, STDOUT.closed?
+
+      appender = ::Logging::Appenders::Stdout.new('foo')
+      assert_equal 'foo', appender.name
+
+      appender = ::Logging::Appenders::Stdout.new(:level => :warn)
+      assert_equal 'stdout', appender.name
+      assert_equal 2, appender.level
+
+      appender = ::Logging::Appenders::Stdout.new('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
     end
 
   end  # class TestStdout
 
   class TestStderr < Test::Unit::TestCase
+    include LoggingTestCase
 
     def test_initialize
+      ::Logging::Repository.instance
+
       appender = ::Logging::Appenders::Stderr.new
       assert_equal 'stderr', appender.name
       assert_same STDERR, appender.instance_variable_get(:@io)
@@ -29,6 +45,17 @@ module TestAppenders
       appender.close
       assert_equal true, appender.closed?
       assert_equal false, STDERR.closed?
+
+      appender = ::Logging::Appenders::Stderr.new('foo')
+      assert_equal 'foo', appender.name
+
+      appender = ::Logging::Appenders::Stderr.new(:level => :warn)
+      assert_equal 'stderr', appender.name
+      assert_equal 2, appender.level
+
+      appender = ::Logging::Appenders::Stderr.new('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
     end
 
   end  # class TestStderr

data/test/appenders/test_io.rb

@@ -38,10 +38,10 @@ module TestAppenders
       # setup an internal logger to capture error messages from the IO
       # appender
       log = StringIO.new
-      Logging::Logger[Logging::Appenders::IO].add_appenders(
+      Logging::Logger[Logging].add_appenders(
         Logging::Appenders::IO.new('__internal_io', log)
       )
-      Logging::Logger[Logging::Appenders::IO].level = 'all'
+      Logging::Logger[Logging].level = 'all'
 
 
       # close the string IO object so we get an error
@@ -51,7 +51,7 @@ module TestAppenders
       @appender.append event
 
       log.seek 0
-      assert_equal "ERROR  Logging::Appenders::IO : <IOError> not opened for writing", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
 
       assert_equal false, @appender.closed?
       assert_equal 5, @appender.level
@@ -92,17 +92,17 @@ module TestAppenders
       # setup an internal logger to capture error messages from the IO
       # appender
       log = StringIO.new
-      Logging::Logger[Logging::Appenders::IO].add_appenders(
+      Logging::Logger[Logging].add_appenders(
         Logging::Appenders::IO.new('__internal_io', log)
       )
-      Logging::Logger[Logging::Appenders::IO].level = 'all'
+      Logging::Logger[Logging].level = 'all'
 
       # close the string IO object so we get an error
       @sio.close
       @appender << 'oopsy'
 
       log.seek 0
-      assert_equal "ERROR  Logging::Appenders::IO : <IOError> not opened for writing", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
 
       # and the appender does not close itself
       assert_equal false, @appender.closed?

data/test/test_appender.rb

@@ -155,6 +155,11 @@ module TestLogging
       assert_equal 'test_appender', @appender.name
     end
 
+    def test_inspect
+      expected = "<Appender:0x%x name=\"test_appender\">" % @appender.object_id
+      assert_equal expected, @appender.inspect
+    end
+
   end  # class TestAppender
 end  # module TestLogging
 

data/test/test_logger.rb

@@ -638,6 +638,64 @@ module TestLogging
       assert_raise(ArgumentError) {log.trace = Object}
     end
 
+    def test_dump_configuration
+      log_a = ::Logging::Logger['A-logger']
+      log_b = ::Logging::Logger['A-logger::B-logger']
+      log_c = ::Logging::Logger['A-logger::B-logger::C-logger']
+      log_d = ::Logging::Logger['A-logger::D-logger']
+
+      sio = StringIO.new
+
+      log_a._dump_configuration( sio )
+      assert_equal(
+        "A-logger  ........................................   debug  +A  -T\n", sio.to_s)
+
+      log_b._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger  ..............................   debug  +A  -T\n", sio.to_s)
+
+      log_c._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger::C-logger  ....................   debug  +A  -T\n", sio.to_s)
+
+      log_d._dump_configuration( sio )
+      assert_equal(
+        "A-logger::D-logger  ..............................   debug  +A  -T\n", sio.to_s)
+
+      log_b.level = :warn
+      log_b.trace = true
+      log_b._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger  ..............................   *warn  +A  +T\n", sio.to_s)
+
+      log_c.additive = false
+      log_c._dump_configuration( sio )
+      assert_equal(
+        "A-logger::B-logger::C-logger  ....................    warn  -A  -T\n", sio.to_s)
+
+      # with an indent specified
+      log_a._dump_configuration( sio, 4 )
+      assert_equal(
+        "    A-logger  ....................................   debug  +A  -T\n", sio.to_s)
+
+      log_b._dump_configuration( sio, 8 )
+      assert_equal(
+        "        A-logger::B-logger  ......................   *warn  +A  +T\n", sio.to_s)
+
+      log_c._dump_configuration( sio, 10 )
+      assert_equal(
+        "          A-logger::B-logger::C-logger  ..........    warn  -A  -T\n", sio.to_s)
+
+      log_d._dump_configuration( sio, 22 )
+      assert_equal(
+        "                      A-logger::D-logger  ........   debug  +A  -T\n", sio.to_s)
+
+      log_c.level = 0
+      log_c._dump_configuration( sio, 26 )
+      assert_equal(
+        "                          A-logger::B...::C-logger  *debug  -A  -T\n", sio.to_s)
+    end
+
   end  # class TestLogger
 
   class SioAppender < ::Logging::Appenders::IO
@@ -661,6 +719,16 @@ module TestLogging
     end
 
   end  # class SioAppender
+
 end  # module TestLogging
 
+class StringIO
+  def to_s
+    seek 0
+    str = read
+    seek 0
+    return str
+  end
+end
+
 # EOF

data/test/test_logging.rb

@@ -20,10 +20,7 @@ module TestLogging
 
       ::Logging.configure 'data/logging.yaml'
 
-      names = {
-        0 => 'DEB', 1 => 'INF', 2 => 'PRT',
-        3 => 'WRN', 4 => 'ERR', 5 => 'FAT'
-      }
+      names = %w[DEB INF PRT WRN ERR FAT]
       assert_equal names, ::Logging::LNAMES
       assert_equal :inspect, ::Logging::OBJ_FORMAT
       assert_equal 3, ::Logging::Logger.root.level
@@ -54,7 +51,7 @@ module TestLogging
 
       # verify the loggers
       h = ::Logging::Repository.instance.instance_variable_get :@h
-      assert_equal 6, h.length
+      assert_equal 4, h.length
 
       # mylogger
       mylogger = ::Logging::Logger['mylogger']
@@ -118,9 +115,8 @@ module TestLogging
     end
 
     def test_init_default
-      empty = {}
-      assert_equal empty, @levels
-      assert_equal empty, @lnames
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
       assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
 
       ::Logging::Repository.instance
@@ -143,9 +139,8 @@ module TestLogging
     end
 
     def test_init_special
-      empty = {}
-      assert_equal empty, @levels
-      assert_equal empty, @lnames
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
       assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
 
       assert_raise(ArgumentError) {::Logging.init(1, 2, 3, 4)}
@@ -170,16 +165,15 @@ module TestLogging
     end
 
     def test_init_all_off
-      empty = {}
-      assert_equal empty, @levels
-      assert_equal empty, @lnames
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
       assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
 
       ::Logging.init %w(a b all c off d)
 
       assert_equal 4, @levels.length
       assert_equal 4, @lnames.length
-      assert_equal 1, ::Logging::MAX_LEVEL_LENGTH
+      assert_equal 3, ::Logging::MAX_LEVEL_LENGTH
 
       assert_equal 0, @levels['a']
       assert_equal 1, @levels['b']

data/test/test_utils.rb

@@ -5,7 +5,7 @@ module TestLogging
 
   class TestUtils < Test::Unit::TestCase
 
-    def test_getopt
+    def test_hash_getopt
       opts = {
         :foo => 'foo_value',
         'bar' => 'bar_value',
@@ -41,6 +41,49 @@ module TestLogging
       assert_nil opts.getopt(:key, :as => Symbol)
     end
 
+    def test_string_reduce
+      str = 'this is the foobar string'
+      len = str.length
+
+      r = str.reduce(len + 1)
+      assert_same str, r
+
+      r = str.reduce(len)
+      assert_same str, r
+
+      r = str.reduce(len - 1)
+      assert_equal 'this is the...bar string', r
+
+      r = str.reduce(len - 10)
+      assert_equal 'this i...string', r
+
+      r = str.reduce(4)
+      assert_equal 't...', r
+
+      r = str.reduce(3)
+      assert_equal '...', r
+
+      r = str.reduce(0)
+      assert_equal '...', r
+
+      assert_raises(ArgumentError) { str.reduce(-1) }
+
+      r = str.reduce(len - 1, '##')
+      assert_equal 'this is the##obar string', r
+
+      r = str.reduce(len - 10, '##')
+      assert_equal 'this is##string', r
+
+      r = str.reduce(4, '##')
+      assert_equal 't##g', r
+
+      r = str.reduce(3, '##')
+      assert_equal 't##', r
+
+      r = str.reduce(0, '##')
+      assert_equal '##', r
+    end
+
   end  # class TestUtils
 end  # module TestLogging
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: logging
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,20 +9,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-16 00:00:00 -06:00
+date: 2008-08-14 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: flexmock
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.8.0
+        version: 0.8.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: lockfile
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -123,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: logging
-rubygems_version: 1.1.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A flexible and extendable logging library for Ruby