logging 1.8.2 → 2.0.0

data/lib/logging/log_event.rb

@@ -17,17 +17,17 @@ module Logging
     # :startdoc:
 
     # call-seq:
-    #    LogEvent.new( logger, level, [data], trace )
+    #    LogEvent.new( logger, level, [data], caller_tracing )
     #
     # Creates a new log event with the given _logger_ name, numeric _level_,
-    # array of _data_ from the user to be logged, and boolean _trace_ flag.
-    # If the _trace_ flag is set to +true+ then Kernel::caller will be
+    # array of _data_ from the user to be logged, and boolean _caller_tracing_ flag.
+    # If the _caller_tracing_ flag is set to +true+ then Kernel::caller will be
     # invoked to get the execution trace of the logging method.
     #
-    def initialize( logger, level, data, trace )
+    def initialize( logger, level, data, caller_tracing )
       f = l = m = ''
 
-      if trace
+      if caller_tracing
         stack = Kernel.caller[CALLER_INDEX]
         return if stack.nil?
 

data/lib/logging/logger.rb

@@ -28,50 +28,36 @@ module Logging
 
     class << self
 
-      # call-seq:
-      #    Logger.root
-      #
       # Returns the root logger.
-      #
       def root
         ::Logging::Repository.instance[:root]
       end
 
-      # :stopdoc:
+      alias_method :instantiate, :new  # the "real" new
 
       # Overrides the new method such that only one Logger will be created
       # for any given logger name.
-      #
       def new( *args )
-        return super if args.empty?
+        args.empty? ? super : self[args.shift]
+      end
 
+      # Returns a logger instance for the given name.
+      def []( name )
         repo = ::Logging::Repository.instance
-        name = repo.to_key(args.shift)
+        name = repo.to_key(name)
+        logger = repo[name]
+        return logger unless logger.nil?
 
         @mutex.synchronize do
           logger = repo[name]
-          if logger.nil?
-
-            master = repo.master_for(name)
-            if master
-              if repo.has_logger?(master)
-                logger = repo[master]
-              else
-                logger = super(master)
-                repo[master] = logger
-                repo.children(master).each {|c| c.__send__(:parent=, logger)}
-              end
-              repo[name] = logger
-            else
-              logger = super(name)
-              repo[name] = logger
-              repo.children(name).each {|c| c.__send__(:parent=, logger)}
-            end
-          end
+          return logger unless logger.nil? # thread-safe double checking
+
+          logger = instantiate(name)
+          repo[name] = logger
+          repo.children(name).each { |c| c.__send__(:parent=, logger) }
           logger
         end
       end
-      alias :[] :new
 
       # This is where the actual logging methods are defined. Two methods
       # are created for each log level. The first is a query method used to
@@ -110,7 +96,7 @@ module Logging
               def #{name}?( ) true end
               def #{name}( data = nil )
                 data = yield if block_given?
-                log_event(::Logging::LogEvent.new(@name, #{num}, data, @trace))
+                log_event(::Logging::LogEvent.new(@name, #{num}, data, @caller_tracing))
                 true
               end
             CODE
@@ -120,11 +106,9 @@ module Logging
         end
         logger
       end
-      # :startdoc:
-
     end  # class << self
 
-    attr_reader :name, :parent, :additive, :trace
+    attr_reader :name, :parent, :additive, :caller_tracing
 
     # call-seq:
     #    Logger.new( name )
@@ -183,7 +167,7 @@ module Logging
       @appenders.each {|a| a << msg}
       @parent << msg if @additive
     end
-    alias :write :<<
+    alias_method :write, :<<
 
     # call-seq:
     #    add( severity, message = nil ) {block}
@@ -214,7 +198,7 @@ module Logging
       return false if lvl < level
 
       data = yield if block_given?
-      log_event(::Logging::LogEvent.new(@name, lvl, data, @trace))
+      log_event(::Logging::LogEvent.new(@name, lvl, data, @caller_tracing))
       true
     end
 
@@ -234,18 +218,19 @@ module Logging
     end
 
     # call-seq:
-    #    trace = true
-    #
-    # Sets the tracing of the logger. Acceptable values are +true+,
-    # 'true', +false+, 'false', or +nil+. In this case +nil+ does not
-    # change the tracing.
-    #
-    def trace=( val )
-      @trace = case val
-               when true, 'true'; true
-               when false, 'false'; false
-               when nil; @trace
-               else raise ArgumentError, 'expecting a boolean' end
+    #    caller_tracing = true
+    #
+    # Sets the caller tracing of the logger. Acceptable values are +true+,
+    # 'true', +false+, 'false', or +nil+. In this case +nil+ does not change
+    # the tracing.
+    #
+    def caller_tracing=( val )
+      @caller_tracing =
+          case val
+          when true, 'true'; true
+          when false, 'false'; false
+          when nil; @caller_tracing
+          else raise ArgumentError, 'expecting a boolean' end
     end
 
     # call-seq:
@@ -443,11 +428,13 @@ module Logging
     #
     def _setup( name, opts = {} )
       @name      = name
-      @parent    = opts.getopt(:parent)
-      @appenders = opts.getopt(:appenders, [])
-      @additive  = opts.getopt(:additive, true)
-      @trace     = opts.getopt(:trace, false)
-      @level     = opts.getopt(:level)
+      @parent    = opts.fetch(:parent, nil)
+      @appenders = opts.fetch(:appenders, [])
+      @additive  = opts.fetch(:additive, true)
+      @level     = opts.fetch(:level, nil)
+
+      @caller_tracing = opts.fetch(:caller_tracing, false)
+
       ::Logging::Logger.define_log_methods(self)
     end
 
@@ -456,21 +443,21 @@ module Logging
     #
     # 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.
+    # level, additivity, and caller_tracing settings. The configured appenders
+    # are also printed to the _io_ stream.
     #
-    def _dump_configuration( io = STDOUT, indent = 0 )
+    def _dump_configuration( indent = 0 )
       str, spacer, base = '', '  ', 50
       indent_str = indent == 0 ? '' : ' ' * indent
 
       str << indent_str
-      str << self.name.reduce(base - indent)
+      str << self.name.shrink(base - indent)
       if (str.length + spacer.length) < base
         str << spacer
         str << '.' * (base - str.length)
       end
-      io.write(str.ljust(base))
-      io.write(spacer)
+      str = str.ljust(base)
+      str << spacer
 
       level_str  = @level.nil? ? '' : '*'
       level_str << if level < ::Logging::LEVELS.length
@@ -480,27 +467,27 @@ module Logging
       end
       level_len = ::Logging::MAX_LEVEL_LENGTH + 1
 
-      io.write("%#{level_len}s" % level_str)
-      io.write(spacer)
+      str << sprintf("%#{level_len}s" % level_str)
+      str << spacer
 
       if self.respond_to?(:additive)
-        io.write(additive ? '+A' : '-A')
+        str << (additive ? '+A' : '-A')
       else
-        io.write('  ')
+        str << '  '
       end
 
-      io.write(spacer)
-      io.write(trace ? '+T' : '-T')
-      io.write("\n")
+      str << spacer
+      str << (caller_tracing ? '+T' : '-T')
+      str << "\n"
 
       @appenders.each do |appender|
-        io.write(indent_str)
-        io.write('- ')
-        io.write(appender.inspect)
-        io.write("\n")
+        str << indent_str
+        str << '- '
+        str << appender.inspect
+        str << "\n"
       end
 
-      return io
+      return str
     end
     # :startdoc:
 

data/lib/logging/repository.rb

@@ -18,7 +18,6 @@ module Logging
     # +Repository+ instance.
     #
     def initialize
-      @masters = []
       @h = {:root => ::Logging::RootLogger.new}
 
       # configures the internal logger which is disabled by default
@@ -71,7 +70,7 @@ module Logging
     # call-seq:
     #    fetch( name )
     #
-    # Returns the +Logger+ named _name_. An +IndexError+ will be raised if
+    # Returns the +Logger+ named _name_. An +KeyError+ will be raised if
     # the logger does not exist.
     #
     # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
@@ -94,6 +93,29 @@ module Logging
     #
     def has_logger?( key ) @h.has_key?(to_key(key)) end
 
+    # call-seq:
+    #    delete( name )
+    #
+    # Deletes the named logger from the repository. All direct children of the
+    # logger will have their parent reassigned. So the parent of the logger
+    # being deleted becomes the new parent of the children.
+    #
+    # When _name_ is a +String+ or a +Symbol+ it will be used "as is" to
+    # remove the logger. When _name_ is a +Class+ the class name will be
+    # used to remove the logger. When _name_ is an object the name of the
+    # object's class will be used to remove the logger.
+    #
+    # Raises a RuntimeError if you try to delete the root logger.
+    # Raises an KeyError if the named logger is not found.
+    def delete( key )
+      key = to_key(key)
+      raise 'the :root logger cannot be deleted' if :root == key
+
+      parent = @h.fetch(key).parent
+      children(key).each {|c| c.__send__(:parent=, parent)}
+      @h.delete(key)
+    end
+
     # call-seq:
     #    parent( key )
     #
@@ -167,43 +189,6 @@ module Logging
       p
     end
 
-    # call-seq:
-    #    add_master( 'First::Name', 'Second::Name', ... )
-    #
-    # Add the given logger names to the list of consolidation masters. All
-    # classes in the given namespace(s) will use these loggers instead of
-    # creating their own individual loggers.
-    #
-    def add_master( *args )
-      args.map do |key|
-        key = to_key(key)
-        @masters << key unless @masters.include? key
-        key
-      end
-    end
-
-    # call-seq:
-    #    master_for( key )
-    #
-    # Returns the consolidation master name for the given _key_. If there is
-    # no consolidation master, then +nil+ is returned.
-    #
-    def master_for( key )
-      return if @masters.empty?
-      key = to_key(key)
-
-      loop do
-        break key if @masters.include? key
-        break nil if :root == key
-
-        if index = key.rindex(PATH_DELIMITER)
-          key = key.slice(0, index)
-        else
-          key = :root
-        end
-      end
-    end
-
     # :stopdoc:
     def self.reset
       if defined?(@singleton__instance__)

data/lib/logging/root_logger.rb

@@ -26,7 +26,7 @@ module Logging
       @name = 'root'
       @appenders = []
       @additive = false
-      @trace = false
+      @caller_tracing = false
       @level = 0
       ::Logging::Logger.define_log_methods(self)
     end

data/lib/logging/utils.rb

@@ -2,61 +2,19 @@
 require 'thread'
 require 'rbconfig'
 
-# --------------------------------------------------------------------------
-class Hash
-
-  # call-seq:
-  #    getopt( key, default = nil, :as => class )
-  #
-  # Returns the value associated with the _key_. If the has does not contain
-  # the _key_, then the _default_ value is returned.
-  #
-  # Optionally, the value can be converted into to an instance of the given
-  # _class_. The supported classes are:
-  #
-  #     Integer
-  #     Float
-  #     Array
-  #     String
-  #     Symbol
-  #
-  # If the value is +nil+, then no conversion will be performed.
-  #
-  def getopt( *args )
-    opts = args.last.instance_of?(Hash) ? args.pop : {}
-    key, default = args
-
-    val = if has_key?(key);                self[key]
-          elsif has_key?(key.to_s);        self[key.to_s]
-          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
-          else default end
-
-    return if val.nil?
-    return val unless opts.has_key?(:as)
-
-    case opts[:as].name.intern
-    when :Integer; Integer(val)
-    when :Float;   Float(val)
-    when :Array;   Array(val)
-    when :String;  String(val)
-    when :Symbol;  String(val).intern
-    else val end
-  end
-end
-
 # --------------------------------------------------------------------------
 class String
 
   # call-seq:
-  #    reduce( width, ellipses = '...' )    #=> string
+  #    shrink( width, ellipses = '...' )    #=> string
   #
-  # Reduce the size of the current string to the given _width_ by removing
+  # Shrink the size of the current string to the given _width_ by removing
   # characters from the middle of the string 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 = '...')
+  def shrink( width, ellipses = '...')
     raise ArgumentError, "width cannot be negative: #{width}" if width < 0
 
     return self if length <= width
@@ -108,25 +66,6 @@ class Module
   end
 end
 
-# --------------------------------------------------------------------------
-module Kernel
-
-  # call-seq:
-  #    require?( string )
-  #
-  # Attempt to the load the library named _string_ using the standard
-  # Kernel#require method. Returns +true+ if the library was successfully
-  # loaded. Returns +false+ if the library could not be loaded. This method
-  # will never raise an exception.
-  #
-  def require?( string )
-    require string
-    return true
-  rescue LoadError
-    return false
-  end
-end  # module Kernel
-
 # --------------------------------------------------------------------------
 class File
 
@@ -211,7 +150,7 @@ class ReentrantMutex < Mutex
     @locker = nil
   end
 
-  alias :original_synchronize :synchronize
+  alias_method :original_synchronize, :synchronize
 
   def synchronize
     if @locker == Thread.current

data/lib/logging/version.rb

@@ -0,0 +1,8 @@
+module Logging
+  VERSION = "2.0.0".freeze
+
+  # Returns the version string for the library.
+  def self.version
+    VERSION
+  end
+end