log4ruby 0.0.1 → 0.0.2

data/lib/log4ruby/appender.rb

@@ -1,42 +1,42 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # Base class for appenders.
-  class Appender
-
-    # Set the formatter this appender uses.
-    attr_writer :formatter
-
-    # New appender. This class should be treated as an abstract base class and should not be initialised directly.
-    #
-    # @param [Log4Ruby::Level] level the threshold level for the appender.
-    # @param [Log4Ruby::Formatter] formatter the formatter the appender uses.
-    def initialize(level, formatter)
-      @level = level
-      @formatter = formatter
-    end
-
-    # Process the log item.
-    #
-    # @param [Log4Ruby::Log] log
-    def process_log(log)
-      return if log[:level] < @level
-
-      # Format the log item and emit it.
-      emit(@formatter.format(log))
-    end
-
-    private
-
-    # Emits a log message to this appenders target.
-    #
-    # @param [String] message the message to emit.
-    def emit(message)
-    end
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # Base class for appenders.
+  class Appender
+
+    # Set the formatter this appender uses.
+    attr_writer :formatter
+
+    # New appender. This class should be treated as an abstract base class and should not be initialised directly.
+    #
+    # @param [Log4Ruby::Level] level the threshold level for the appender.
+    # @param [Log4Ruby::Formatter] formatter the formatter the appender uses.
+    def initialize(level, formatter)
+      @level = level
+      @formatter = formatter
+    end
+
+    # Process the log item.
+    #
+    # @param [Log4Ruby::Log] log
+    def process_log(log)
+      return if log[:level] < @level
+
+      # Format the log item and emit it.
+      emit(@formatter.format(log))
+    end
+
+    private
+
+    # Emits a log message to this appenders target.
+    #
+    # @param [String] message the message to emit.
+    def emit(message)
+    end
+
+  end
+
 end

data/lib/log4ruby/appenders/nil_appender.rb

@@ -1,16 +1,16 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # An appender that does nothing. All logs to it are ignored and just consumed.
-  class NilAppender
-
-    # Don't do anything with the log. Just return.
-    def process_log(log)
-    end
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # An appender that does nothing. All logs to it are ignored and just consumed.
+  class NilAppender
+
+    # Don't do anything with the log. Just return.
+    def process_log(log)
+    end
+
+  end
+
 end

data/lib/log4ruby/appenders/stream_appender.rb

@@ -1,31 +1,31 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/appender"
-
-module Log4Ruby
-
-  # Simple appender that can emit to a stream (file, console, socket, etc i.e. anything that responds to the write method)
-  class StreamAppender < Log4Ruby::Appender
-
-    # New stream appender.
-    #
-    # @param [IO] stream a IO stream that can respond to the write method.
-    def initialize(level, formatter, stream)
-      super(level, formatter)
-      @stream = stream
-    end
-
-    private
-
-    # Writes the message to the underlying stream.
-    #
-    # @param [String] message the message to write.
-    def emit(message)
-      @stream.write(message)
-    end
-
-  end
-
-end
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/appender"
+
+module Log4Ruby
+
+  # Simple appender that can emit to a stream (file, console, socket, etc i.e. anything that responds to the write method)
+  class StreamAppender < Log4Ruby::Appender
+
+    # New stream appender.
+    #
+    # @param [IO] stream a IO stream that can respond to the write method.
+    def initialize(level, formatter, stream)
+      super(level, formatter)
+      @stream = stream
+    end
+
+    private
+
+    # Writes the message to the underlying stream.
+    #
+    # @param [String] message the message to write.
+    def emit(message)
+      @stream.write(message)
+    end
+
+  end
+
+end

data/lib/log4ruby/exceptions.rb

@@ -1,10 +1,10 @@
-#
-# 22 Jul 2012
-#
-
-module Log4Ruby
-
-  class LoggerNotFoundError < Exception
-  end
-
+#
+# 22 Jul 2012
+#
+
+module Log4Ruby
+
+  class LoggerNotFoundError < Exception
+  end
+
 end

data/lib/log4ruby/formatter.rb

@@ -1,20 +1,20 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # Base class for all formatters.
-  class Formatter
-
-    # Format a log item.
-    #
-    # @param [Log4Ruby::Log] log
-    #
-    # @return [String] the fully formatted log message.
-    def format(log)
-    end
-
-  end
-
-end
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # Base class for all formatters.
+  class Formatter
+
+    # Format a log item.
+    #
+    # @param [Log4Ruby::Log] log
+    #
+    # @return [String] the fully formatted log message.
+    def format(log)
+    end
+
+  end
+
+end

data/lib/log4ruby/formatters/pattern_formatter.rb

@@ -1,51 +1,81 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/formatter"
-require "log4ruby/log"
-
-module Log4Ruby
-
-  class PatternFormatter
-
-    # New pattern formatted.
-    #
-    # @param [String] format_string the pattern string to use when formatting log messages.
-    # @param [Array] subst_array the log parameters to substitute into the format string.
-    # @param [Hash] custom_formatters custom formatters for log parameters. Maps parameter names to callable objects
-    #   that will be invoked with the parameter's value. The values returned will be used when substituting into the
-    #   format string.
-    #
-    # e.g.
-    # format_string = [%s] %7s - %s : %s
-    # subst_array = [:timestamp, :level, :full_logger_name, :message]
-    # custom_formatters = {:timestamp => Proc.new { |value| value.strftime("%Y-%m-%d %H:%M:%S.%L") }}
-    #
-    # The above example will print the timestamp in the format specified.
-    # The level will be right aligned padded on the left to use 7 spaces followed by the full logger name and the
-    # message.
-    def initialize(format_string, subst_array, custom_formatters = {})
-      @format_string = get_option(options, :format_string)
-      @subst_array = get_option(options, :subst_array)
-      @custom_formatters = get_option(options, :custom_formatters)
-    end
-
-    # Format the log item using the pattern string.
-    #
-    # @param [Log4Ruby::Log] log the log to format.
-    #
-    # @return [String] the fully formatted log message.
-    def format(log)
-      # Get the values of the parameters (apply custom formatters too).
-      parameters = @subst_array.map do |parameter|
-        value = log[parameter]
-        @custom_formatters.has_key?(parameter) ? @custom_formatters[parameter].call(value) : value.to_s
-      end
-      # Substitute into the format string.
-      @format_string % parameters
-    end
-
-  end
-
-end
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/formatter"
+require "log4ruby/log"
+
+module Log4Ruby
+
+  class PatternFormatter
+
+    # New pattern formatter.
+    #
+    # @param [String] format_string the pattern string to use when formatting log messages.
+    # @param [Array] subst_array the log parameters to substitute into the format string.
+    # @param [Hash] parameter_formatters custom formatters for log parameters. Maps parameter names to callable objects
+    #   that will be invoked with the parameter's value. The values returned will be used when substituting into the
+    #   format string.
+    #
+    # e.g.
+    # format_string = [%s] %7s - %s : %s
+    # subst_array = [:timestamp, :level, :full_logger_name, :message]
+    # custom_formatters = {:timestamp => Proc.new { |value| value.strftime("%Y-%m-%d %H:%M:%S.%L") }}
+    #
+    # The above example will print the timestamp in the format specified.
+    # The level will be right aligned padded on the left to use 7 spaces followed by the full logger name and the
+    # message.
+    def initialize(format_string, subst_array, parameter_formatters = {})
+      @format_string = format_string
+      @subst_array = subst_array
+      @parameter_formatters = parameter_formatters
+    end
+
+    # Adds a parameter formatter to this formatter.
+    #
+    # @param [Symbol] parameter the parameter to format.
+    # @param [Proc] callable the callable to invoke.
+    def add_parameter_formatter(parameter, callable)
+      @parameter_formatters[parameter] = callable
+    end
+
+    # Format the log item using the pattern string.
+    #
+    # @param [Log4Ruby::Log] log the log to format.
+    #
+    # @return [String] the fully formatted log message.
+    def format(log)
+      # Get the values of the parameters (apply custom formatters too).
+      parameters = @subst_array.map do |parameter|
+        value = log[parameter]
+        @parameter_formatters.has_key?(parameter) ? @parameter_formatters[parameter].call(value) : value.to_s
+      end
+      # Substitute into the format string.
+      @format_string % parameters
+    end
+
+  end
+
+  # Some common parameter formatters to use with the pattern formatter.
+  class ParameterFormatters
+
+    # Returns a logger formatter that will format logger objects.
+    #
+    # @param [Integer] index an integer that represents how far up the tree the logger's name should be resolved. So
+    # 1 would be only the name of the logger, 2 would be the name of the logger's parent and the name of the logger,
+    # and so on...
+    def self.logger_formatter(index)
+      start =  0 - index
+      Proc.new { |logger| logger.full_name.split(".")[start..-1].join(".") }
+    end
+
+    # Returns a timestamp formatter that will format time objects using the specified format string.
+    #
+    # @param [String] format_string the format string.
+    def self.timestamp_formatter(format_string)
+      Proc.new { |timestamp| timestamp.strftime(format_string) }
+    end
+
+  end
+
+end

data/lib/log4ruby/level.rb

@@ -1,94 +1,94 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/logger"
-
-module Log4Ruby
-
-  class Level
-
-    # Creates a new level with the specified name and weight. Only level's created using this method are
-    # automatically made available on the Logger class. Any other level's will have to be handled manually.
-    # The method with which it is made available is the same as the level, but with all lowercase characters.
-    #
-    # @param [String] name the name of the new level. Will overwrite an existing level with the same name, if it exists.
-    #   The name is converted to all uppercase characters.
-    # @param [Float] weight the weight of the level. Higher the weight, higher the priority.
-    def self.register(name, weight)
-      name = name.upcase
-      method_name = name.downcase
-      query_method_name = "#{method_name}?"
-      level = Level.new(name, weight)
-      const_set(name, level)
-      # Create the logging method.
-      Logger.send(:define_method, method_name) do |message, parameters = {}|
-        return if level < self.effective_level
-        # Construct the log and dispatch it.
-        parameters[:message] = message
-        parameters[:level] = level
-        parameters[:logger] = self
-        self.process_log(Log.new(parameters))
-      end
-      # Create the query method - for checking the effective level of a logger / appender.
-      Logger.send(:define_method, query_method_name) { self.effective_level <= level  }
-      Appender.send(:define_method, query_method_name) { self.level <= level }
-    end
-
-    # Parses the specified string in an attempt to convert it to a Level object.
-    #
-    # @param [String] name the name of the level.
-    #
-    # @return [Log4Ruby::Level] the level object.
-    def self.parse(name)
-      name = name.upcase
-      const_get(name)
-    end
-
-    # The weight of this level. Higher the value, more severe the log.
-    attr_reader :weight
-    # The name of the level.
-    attr_reader :name
-
-    # Creates a new level.
-    #
-    # @param [String] name the name of the level.
-    # @param [Float] weight the weight for this level. Higher the weight, higher the severity.
-    def initialize(name, weight)
-      @name = name
-      @weight = weight
-    end
-
-    # Check if this level is less than the specified other log level.
-    # Comparison is done using the weight attribute
-    def <(other)
-      self.weight < other.weight
-    end
-
-    # Check if this level is less than or equal to the specified other log level.
-    # Comparison is done using the weight attribute
-    def <=(other)
-      self.weight <= other.weight
-    end
-
-    # Override to return the name of the level.
-    #
-    # @return [String] the level's name.
-    def to_s
-      @name
-    end
-
-    register("ALL", Float::MIN)
-    register("TRACE", 100.0)
-    register("FINE", 200.0)
-    register("DEBUG", 300.0)
-    register("CONF", 400.0)
-    register("INFO", 500.0)
-    register("WARN", 600.0)
-    register("ERROR", 700.0)
-    register("FATAL", 800.0)
-    register("OFF", Float::MAX)
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/logger"
+
+module Log4Ruby
+
+  class Level
+
+    # Creates a new level with the specified name and weight. Only level's created using this method are
+    # automatically made available on the Logger class. Any other level's will have to be handled manually.
+    # The method with which it is made available is the same as the level, but with all lowercase characters.
+    #
+    # @param [String] name the name of the new level. Will overwrite an existing level with the same name, if it exists.
+    #   The name is converted to all uppercase characters.
+    # @param [Float] weight the weight of the level. Higher the weight, higher the priority.
+    def self.register(name, weight)
+      name = name.upcase
+      method_name = name.downcase
+      query_method_name = "#{method_name}?"
+      level = Level.new(name, weight)
+      const_set(name, level)
+      # Create the logging method.
+      Logger.send(:define_method, method_name) do |message, parameters = {}|
+        return if level < self.effective_level
+        # Construct the log and dispatch it.
+        parameters[:message] = message
+        parameters[:level] = level
+        parameters[:logger] = self
+        self.process_log(Log.new(parameters))
+      end
+      # Create the query method - for checking the effective level of a logger / appender.
+      Logger.send(:define_method, query_method_name) { self.effective_level <= level  }
+      Appender.send(:define_method, query_method_name) { self.level <= level }
+    end
+
+    # Parses the specified string in an attempt to convert it to a Level object.
+    #
+    # @param [String] name the name of the level.
+    #
+    # @return [Log4Ruby::Level] the level object.
+    def self.parse(name)
+      name = name.upcase
+      const_get(name)
+    end
+
+    # The weight of this level. Higher the value, more severe the log.
+    attr_reader :weight
+    # The name of the level.
+    attr_reader :name
+
+    # Creates a new level.
+    #
+    # @param [String] name the name of the level.
+    # @param [Float] weight the weight for this level. Higher the weight, higher the severity.
+    def initialize(name, weight)
+      @name = name
+      @weight = weight
+    end
+
+    # Check if this level is less than the specified other log level.
+    # Comparison is done using the weight attribute
+    def <(other)
+      self.weight < other.weight
+    end
+
+    # Check if this level is less than or equal to the specified other log level.
+    # Comparison is done using the weight attribute
+    def <=(other)
+      self.weight <= other.weight
+    end
+
+    # Override to return the name of the level.
+    #
+    # @return [String] the level's name.
+    def to_s
+      @name
+    end
+
+    register("ALL", Float::MIN)
+    register("TRACE", 100.0)
+    register("FINE", 200.0)
+    register("DEBUG", 300.0)
+    register("CONF", 400.0)
+    register("INFO", 500.0)
+    register("WARN", 600.0)
+    register("ERROR", 700.0)
+    register("FATAL", 800.0)
+    register("OFF", Float::MAX)
+
+  end
+
 end

data/lib/log4ruby/log.rb

@@ -1,36 +1,36 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # Represents a log item.
-  class Log
-
-    attr_reader :parameters
-
-    # A hash containing all the information in this log.
-    # A message, level and logger are the only mandatory parameters.
-    def initialize(parameters = {})
-      @message = get_option(parameters, :message, true)
-      @level = get_option(parameters, :level, true)
-      @logger = get_option(parameters, :logger, true)
-      @timestamp = set_option(parameters, :timestamp, Time.now, true)
-
-      @parameters = parameters
-      @parameters[:logger_name] = @logger.name
-      @parameters[:full_logger_name] = @logger.full_name
-    end
-
-    # Get the specified parameter.
-    #
-    # @param [Symbol] parameter the parameter to get.
-    #
-    # @return [Object] the parameter's value, or nil if the parameter did not exist.
-    def [](parameter)
-      @parameters[parameter]
-    end
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # Represents a log item.
+  class Log
+
+    attr_reader :parameters
+
+    # A hash containing all the information in this log.
+    # A message, level and logger are the only mandatory parameters.
+    def initialize(parameters = {})
+      @message = get_option(parameters, :message, true)
+      @level = get_option(parameters, :level, true)
+      @logger = get_option(parameters, :logger, true)
+      @timestamp = set_option(parameters, :timestamp, Time.now, true)
+
+      @parameters = parameters
+      @parameters[:logger_name] = @logger.name
+      @parameters[:full_logger_name] = @logger.full_name
+    end
+
+    # Get the specified parameter.
+    #
+    # @param [Symbol] parameter the parameter to get.
+    #
+    # @return [Object] the parameter's value, or nil if the parameter did not exist.
+    def [](parameter)
+      @parameters[parameter]
+    end
+
+  end
+
 end

data/lib/log4ruby/logger.rb

@@ -1,127 +1,132 @@
-#
-# 22 Jul 2012
-#
-
-require "singleton"
-
-module Log4Ruby
-
-  # Represents a logger.
-  # Loggers are arranged into a tree, where each logger, after having dispatched the log to its appenders,
-  # forwards the log to its parents too.
-  class Logger
-
-    # The effective level of this logger. This will be the parent's effective level if a level has not been
-    # explicitly set for this logger.
-    attr_reader :effective_level
-    # The full name of this logger.
-    attr_reader :full_name
-    # The name of this logger.
-    attr_reader :name
-    # True to use parent appenders (the default) false to use only this logger's appenders.
-    attr_writer :use_parent_appenders
-
-    # Creates a new logger. Users should not use this method, and should use the Log4Ruby.get_logger method.
-    #
-    # @param [String] name the name for this logger.
-    # @param [Log4Ruby::Logger] parent the parent to this logger. If set to nil, becomes the child of the root logger.
-    # @param [Log4Ruby::Level] level the level of this logger. If set to nil, uses the parent's effective level
-    # (defaults to DEBUG for the root logger).
-    # @param [Array] appenders a list of appenders this logger will use.
-    def initialize(name, parent = nil, level = nil, appenders = [])
-      @name = name
-      @parent = parent.nil? ? RootLogger.instance : parent
-      @level = level
-      @appenders = appenders
-      @children = {}
-
-      @use_parent_appenders = true
-      @full_name = @parent.kind_of?(RootLogger) ? @name : @parent.full_name + "." + @name
-      @effective_level = level.nil? ? @parent.effective_level : level
-    end
-
-    # Adds an appender to this logger.
-    #
-    # @param [Log4Ruby::Appender] appender the appender to add.
-    def add_appender(appender)
-      @appenders << appender
-    end
-
-    # Gets a child logger with the specified name. If the create flag is true, it will create a new logger
-    # with this name.
-    #
-    # @param [String] name the name of the logger.
-    # @param [TrueClass, FalseClass] create if true, create a logger if it does not exist.
-    def get_logger(name, create = false)
-      if @children.has_key?(name)
-        @children[name]
-      elsif create
-        @children[name] = Logger.new(name, self)
-      else
-        raise Log4Ruby::LoggerNotFoundError.new("Logger '#{name}' does not exist under '#@full_name'!")
-      end
-    end
-
-    # Update this logger's level. This will update the effective level for all child loggers too (except for the ones
-    # that have had their level explicitly set.
-    #
-    # @param [Log4Ruby::Level] new_level the new level.
-    def set_level(new_level)
-      @level = new_level
-      @effective_level = new_level
-      @children.each_value { |logger| logger.update_effective_level(new_level) }
-    end
-
-    protected
-
-    # Updates the effective level for this logger. This method is called internally when a logger's level is updated
-    # and should not be invoked directly.
-    #
-    # @param [Log4Ruby::Level] new_level the new effective level.
-    def update_effective_level(new_level)
-      if @level.nil?
-        @effective_level = new_level
-        @children.each_value { |logger| logger.update_effective_level(new_level) }
-      end
-    end
-
-    # Process the log message.
-    #
-    # @param [Log4Ruby::Log] log the log item to process. Does nothing if the log does not meet this logger's
-    # threshold level.
-    def process_log(log)
-      return if log[:level] < @effective_level
-      # Forward to each appender. Once done, send to the parent.
-      @appenders.each { |appender| appender.process_log(log) }
-      @parent.process_log(log) if @use_parent_appenders
-    end
-
-    private
-
-  end
-
-  # Represents the root logger. This logger is similar to any other logger, except since it does not have a parent
-  # logger, it does not forward logs.
-  class RootLogger < Logger
-
-    include Singleton
-
-    # New root logger. The root logger is the parent of all loggers in the system.
-    def initialize
-      @full_name = @name = "Root"
-      @parent = nil
-      @effective_level = @level = Log4Ruby::Level::DEBUG
-      @appenders = []
-      @children = {}
-      @use_parent_appenders = false
-    end
-
-    # Override to do nothing. Since the root doesn't have a parent.
-    #
-    # @param [Log4Ruby::Level] new_level ignored, since the root doesn't have a parent.
-    def use_parent_appenders=(new_level)
-    end
-
-  end
-
+#
+# 22 Jul 2012
+#
+
+require "singleton"
+
+module Log4Ruby
+
+  # Represents a logger.
+  # Loggers are arranged into a tree, where each logger, after having dispatched the log to its appenders,
+  # forwards the log to its parents too.
+  class Logger
+
+    # The effective level of this logger. This will be the parent's effective level if a level has not been
+    # explicitly set for this logger.
+    attr_reader :effective_level
+    # The full name of this logger.
+    attr_reader :full_name
+    # The name of this logger.
+    attr_reader :name
+    # True to use parent appenders (the default) false to use only this logger's appenders.
+    attr_writer :use_parent_appenders
+
+    # Creates a new logger. Users should not use this method, and should use the Log4Ruby.get_logger method.
+    #
+    # @param [String] name the name for this logger.
+    # @param [Log4Ruby::Logger] parent the parent to this logger. If set to nil, becomes the child of the root logger.
+    # @param [Log4Ruby::Level] level the level of this logger. If set to nil, uses the parent's effective level
+    # (defaults to DEBUG for the root logger).
+    # @param [Array] appenders a list of appenders this logger will use.
+    def initialize(name, parent = nil, level = nil, appenders = [])
+      @name = name
+      @parent = parent.nil? ? RootLogger.instance : parent
+      @level = level
+      @appenders = appenders
+      @children = {}
+
+      @use_parent_appenders = true
+      @full_name = @parent.kind_of?(RootLogger) ? @name : @parent.full_name + "." + @name
+      @effective_level = level.nil? ? @parent.effective_level : level
+    end
+
+    # Adds an appender to this logger.
+    #
+    # @param [Log4Ruby::Appender] appender the appender to add.
+    def add_appender(appender)
+      @appenders << appender
+    end
+
+    # Gets a child logger with the specified name. If the create flag is true, it will create a new logger
+    # with this name.
+    #
+    # @param [String] name the name of the logger.
+    # @param [TrueClass, FalseClass] create if true, create a logger if it does not exist.
+    def get_logger(name, create = false)
+      if @children.has_key?(name)
+        @children[name]
+      elsif create
+        @children[name] = Logger.new(name, self)
+      else
+        raise Log4Ruby::LoggerNotFoundError.new("Logger '#{name}' does not exist under '#@full_name'!")
+      end
+    end
+
+    # Update this logger's level. This will update the effective level for all child loggers too (except for the ones
+    # that have had their level explicitly set.
+    #
+    # @param [Log4Ruby::Level] new_level the new level.
+    def set_level(new_level)
+      @level = new_level
+      @effective_level = new_level
+      @children.each_value { |logger| logger.update_effective_level(new_level) }
+    end
+
+    # Returns the full name of the logger.
+    #
+    # @return [String] the full name of the logger.
+    def to_s
+      @full_name
+    end
+
+    protected
+
+    # Updates the effective level for this logger. This method is called internally when a logger's level is updated
+    # and should not be invoked directly.
+    #
+    # @param [Log4Ruby::Level] new_level the new effective level.
+    def update_effective_level(new_level)
+      if @level.nil?
+        @effective_level = new_level
+        @children.each_value { |logger| logger.update_effective_level(new_level) }
+      end
+    end
+
+    # Process the log message.
+    #
+    # @param [Log4Ruby::Log] log the log item to process. Does nothing if the log does not meet this logger's
+    # threshold level.
+    def process_log(log)
+      return if log[:level] < @effective_level
+      # Forward to each appender. Once done, send to the parent.
+      @appenders.each { |appender| appender.process_log(log) }
+      @parent.process_log(log) if @use_parent_appenders
+    end
+
+  end
+
+  # Represents the root logger. This logger is similar to any other logger, except since it does not have a parent
+  # logger, it does not forward logs.
+  class RootLogger < Logger
+
+    include Singleton
+
+    # New root logger. The root logger is the parent of all loggers in the system.
+    def initialize
+      @full_name = @name = "Root"
+      @parent = nil
+      @effective_level = @level = Log4Ruby::Level::DEBUG
+      @appenders = []
+      @children = {}
+      @use_parent_appenders = false
+    end
+
+    # Override to do nothing. Since the root doesn't have a parent.
+    #
+    # @param [Log4Ruby::Level] new_level ignored, since the root doesn't have a parent.
+    def use_parent_appenders=(new_level)
+    end
+
+  end
+
 end

data/lib/log4ruby/rolling_file.rb

@@ -0,0 +1,26 @@
+#
+# 23 Jul 2012
+#
+
+module Log4Ruby
+
+  class RollingFile
+
+    # New rolling file with the specified prefix.
+    #
+    # @param [String] prefix the prefix for all the files that will be created.
+    def initialize(prefix)
+      @prefix = prefix
+    end
+
+  end
+
+  class TimedRollingFile < RollingFile
+
+    # New timed rolling file that will roll over to a new file when the specified time expires.
+    def initialize(prefix, time_to_roll)
+    end
+
+  end
+
+end

data/lib/log4ruby/version.rb

@@ -1,9 +1,9 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  VERSION = "0.0.1"
-
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  VERSION = "0.0.2"
+
 end

data/lib/log4ruby.rb

@@ -1,36 +1,37 @@
-#
-# 21 Jul 2012
-#
-
-require "options_arg"
-
-require "log4ruby/appender"
-require "log4ruby/exceptions"
-require "log4ruby/formatter"
-require "log4ruby/log"
-require "log4ruby/logger"
-
-require "log4ruby/level"
-
-module Log4Ruby
-
-  @@loggers = {}
-
-  # Get a logger with the specified name. The name can be a '.' separated string or a "::" separated string.
-  # Loggers are created only if required.
-  #
-  # @param [String] name the name of the logger to get.
-  #
-  # @return [Log4Ruby::Logger] the logger.
-  def self.get_logger(name)
-    # Return a logger if it had been created earlier.
-    return @@loggers[name] if @@loggers.has_key?(name)
-    # Otherwise, create it.
-    parts = name.index("::") ? name.split("::") : name.split(".")
-    logger = RootLogger.instance
-    parts.each { |part| logger = logger.get_logger(part, true) }
-    # The logger.
-    @@loggers[name] = logger
-  end
-
+#
+# 21 Jul 2012
+#
+
+require "rubygems"
+require "options_arg"
+
+require "log4ruby/appender"
+require "log4ruby/exceptions"
+require "log4ruby/formatter"
+require "log4ruby/log"
+require "log4ruby/logger"
+
+require "log4ruby/level"
+
+module Log4Ruby
+
+  @@loggers = {}
+
+  # Get a logger with the specified name. The name can be a '.' separated string or a "::" separated string.
+  # Loggers are created only if required.
+  #
+  # @param [String] name the name of the logger to get.
+  #
+  # @return [Log4Ruby::Logger] the logger.
+  def self.get_logger(name)
+    # Return a logger if it had been created earlier.
+    return @@loggers[name] if @@loggers.has_key?(name)
+    # Otherwise, create it.
+    parts = name.index("::") ? name.split("::") : name.split(".")
+    logger = RootLogger.instance
+    parts.each { |part| logger = logger.get_logger(part, true) }
+    # The logger.
+    @@loggers[name] = logger
+  end
+
 end

data/lib/tests.rb

@@ -1,38 +1,38 @@
-#
-# 22 Jul 2012
-#
-
-$LOAD_PATH << "."
-
-require "log4ruby"
-require "log4ruby/appenders/stream_appender"
-require "log4ruby/formatters/pattern_formatter"
-
-# The pattern formatter, with a custom parameter formatter for the timestamp.
-timestamp_formatter = Proc.new { |timestamp| timestamp.strftime("%Y-%m-%d %H:%M:%S.%L") }
-formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s\n", [:timestamp, :level, :full_logger_name, :message],
-                                           {:timestamp => timestamp_formatter})
-# Stream appender for printing to stdout.
-console_appender = Log4Ruby::StreamAppender.new(Log4Ruby::Level::ALL, formatter, $stdout)
-
-# Register a custom level FINER, that is between TRACE and FINE
-Log4Ruby::Level.register("FINER", 150.0)
-
-# The logger.
-logger = Log4Ruby.get_logger("Log4Ruby::TestLogger")
-logger.set_level(Log4Ruby::Level::FINER)
-logger.add_appender(console_appender)
-
-puts "Logger will print TRACE? : #{logger.trace?}"
-puts "Logger will print FINER? : #{logger.finer?}"
-puts "Logger will print FINE?  : #{logger.fine?}"
-
-logger.trace("Test!")
-logger.finer("Test!")
-logger.fine("Test!")
-logger.debug("Test!")
-logger.conf("Test!")
-logger.info("Test!")
-logger.warn("Test!")
-logger.error("Test!")
-logger.fatal("Test!")
+#
+# 22 Jul 2012
+#
+
+$LOAD_PATH << "."
+
+require "log4ruby"
+require "log4ruby/appenders/stream_appender"
+require "log4ruby/formatters/pattern_formatter"
+
+# The pattern formatter, with a custom parameter formatter for the timestamp.
+formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s\n", [:timestamp, :level, :logger, :message])
+formatter.add_parameter_formatter(:logger, Log4Ruby::ParameterFormatters.logger_formatter(1))
+formatter.add_parameter_formatter(:timestamp, Log4Ruby::ParameterFormatters.timestamp_formatter("%Y-%m-%d %H:%M:%S.%L"))
+# Stream appender for printing to stdout.
+console_appender = Log4Ruby::StreamAppender.new(Log4Ruby::Level::ALL, formatter, $stdout)
+
+# Register a custom level FINER, that is between TRACE and FINE
+Log4Ruby::Level.register("FINER", 150.0)
+
+# The logger.
+logger = Log4Ruby.get_logger("Log4Ruby::TestLogger")
+logger.set_level(Log4Ruby::Level::FINER)
+logger.add_appender(console_appender)
+
+puts "Logger will print TRACE? : #{logger.trace?}"
+puts "Logger will print FINER? : #{logger.finer?}"
+puts "Logger will print FINE?  : #{logger.fine?}"
+
+logger.trace("Test!")
+logger.finer("Test!")
+logger.fine("Test!")
+logger.debug("Test!")
+logger.conf("Test!")
+logger.info("Test!")
+logger.warn("Test!")
+logger.error("Test!")
+logger.fatal("Test!")

metadata

@@ -1,23 +1,48 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: log4ruby
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
-authors:
+authors: 
 - Suraj Vijayakumar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-22 00:00:00.000000000 Z
-dependencies: []
+
+date: 2012-07-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: options-arg
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 0
+        - 1
+        version: 0.0.1
+  type: :runtime
+  version_requirements: *id001
 description: A logging system for Ruby applications inspired by Java's logging API.
-email:
+email: 
 - vijayakumar.suraj@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/log4ruby/appender.rb
 - lib/log4ruby/appenders/nil_appender.rb
 - lib/log4ruby/appenders/stream_appender.rb
@@ -27,32 +52,42 @@ files:
 - lib/log4ruby/level.rb
 - lib/log4ruby/log.rb
 - lib/log4ruby/logger.rb
+- lib/log4ruby/rolling_file.rb
 - lib/log4ruby/version.rb
 - lib/log4ruby.rb
-- lib/options_arg.rb
 - lib/tests.rb
 homepage: 
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A simple and customizable logging system inspired by Java logging API.
 test_files: []
+

data/lib/options_arg.rb

@@ -1,66 +0,0 @@
-#
-# 16 Jul 2012
-#
-
-# Provides a few methods to work with hashes.
-module Kernel
-
-  # Raised if a required option has not been set.
-  class OptionNotSetError < Exception
-  end
-
-  private
-
-  # Get a value from the specified hash.
-  #
-  # @param [Hash] options the hash.
-  # @param [Symbol] key the key whose value is required.
-  # @param [TrueClass, FalseClass] required flag to indicate if it is an error if the key does not exist.
-  # @param [Object] default the default value if the key does not exist. Only used if 'required' is false.
-  #
-  # @return [Object] the value from the hash, or the default value.
-  def get_option(options, key, required = false, default = nil)
-    if options.has_key?(key)
-      options[key]
-    elsif required
-      raise OptionNotSetError.new("Option '#{key}' has not been set!")
-    else
-      default
-    end
-  end
-
-  # Pops (delete) a value from the specified hash.
-  #
-  # @param [Hash] options the hash.
-  # @param [Symbol] key the key whose value is required.
-  # @param [TrueClass, FalseClass] required flag to indicate if it is an error if the key does not exist.
-  # @param [Object] default the default value if the key does not exist. Only used if 'required' is false.
-  #
-  # @return [Object] the value from the hash, or the default value.
-  def pop_option(options, key, required = false, default = nil)
-    if options.has_key?(key)
-      options.delete(key)
-    elsif required
-      raise OptionNotSetError.new("Option '#{key}' has not been set!")
-    else
-      default
-    end
-  end
-
-  # Sets a value in the specified hash.
-  #
-  # @param [Hash] options the hash.
-  # @param [Symbol] key the key whose value is to be set.
-  # @param [Object] value the value to set.
-  # @param [TrueClass, FalseClass] overwrite flag to indicate if existing values should be overwritten.
-  #
-  # @return [Object] the value in the hash at the end of the operation.
-  def set_option(options, key, value, overwrite)
-    if not options.has_key?(key) or overwrite
-      options[key] = value
-    end
-    # Return whatever is in the hash now.
-    options[key]
-  end
-
-end