sml-log4r 1.0.6

data/src/log4r/rdoc/syslogoutputter

@@ -0,0 +1,29 @@
+= SyslogOutputter
+
+A SyslogOutputter transforms a Log4r::LogEvent into a call to syslog().
+Since syslog has its own formatting system, log4r formatters are ignored. 
+
+== Usage
+
+To use, 
+
+  <tt>require 'log4r/outputter/syslogoutputter'</tt>
+
+An example,
+
+  require 'log4r'
+  require 'log4r/outputter/syslogoutputter'
+
+  syslog = Log4r::SyslogOutputter.new("name", 'logopt'=>#, 'facility'=>#)
+  syslog.err("this is an ERR message")
+
+The output in <tt>/var/logs/syslog</tt> (Debian) is,
+
+  Sep  3 11:43:06 tiphares sys[1603]: this is an ERR message
+
+The hash arguments +logoptions+ and +facility+ are passed to 
+<tt>Syslog.open</tt>. The
+defaults are <tt>LOG_PID | LOG_CONS</tt> and <tt>LOG_USER</tt> respectively.
+
+This is a first try implementation. It works well. Please report 
+any bugs and fixes.

data/src/log4r/rdoc/yamlconfigurator

@@ -0,0 +1,20 @@
+= Configuring Log4r with Log4r::YamlConfigurator
+
+The YamlConfigurator class allows one to set up Log4r via YAML.
+It is used almost exactly as Log4r::Configurator and has the same features,
+
+  ycfg = YamlConfigurator    # handy shorthand
+  ycfg['foo'] = bar          # replaces instances of #{foo} in the YAML with bar
+  ycfg.load_yaml_file('foo.yaml')
+
+Ruby 1.7 and 1.8 comes with a YAML parser. Hence, YAML can be used
+to configure Log4r out of the box.
+
+A comprehensive example of a Log4r YAML configuration is provided in the 
+examples directory.
+
+To use this class:
+
+  require 'log4r/yamlconfigurator'
+
+Thanks to Andreas Hund for making this possible.

data/src/log4r/repository.rb

@@ -0,0 +1,65 @@
+# :nodoc:
+# Version:: $Id: repository.rb,v 1.10 2002/08/20 07:40:26 cepheus Exp $
+
+require "singleton"
+
+module Log4r
+class Logger
+
+  # The repository stores a Hash of loggers keyed to their fullnames and
+  # provides a few functions to reduce the code bloat in log4r/logger.rb.
+  # This class is supposed to be transparent to end users, hence it is
+  # a class within Logger. If anyone knows how to make this private,
+  # let me know.
+  
+  class Repository # :nodoc:
+    include Singleton
+    attr_reader :loggers
+    
+    def initialize
+      @loggers = Hash.new
+    end
+
+    def self.[](fullname)
+      instance.loggers[fullname]
+    end
+
+    def self.[]=(fullname, logger)
+      instance.loggers[fullname] = logger
+    end
+  
+    # Retrieves all children of a parent
+    def self.all_children(parent)
+      # children have the parent name + delimiter in their fullname
+      daddy = parent.name + Private::Config::LoggerPathDelimiter
+      for fullname, logger in instance.loggers
+        yield logger if parent.is_root? || fullname =~ /#{daddy}/
+      end
+    end
+
+    # when new loggers are introduced, they may get inserted into
+    # an existing inheritance tree. this method
+    # updates the children of a logger to link their new parent
+    def self.reassign_any_children(parent)
+      for fullname, logger in instance.loggers
+        next if logger.is_root?
+        logger.parent = parent if logger.path =~ /^#{parent.fullname}$/
+      end
+    end
+    
+    # looks for the first defined logger in a child's path 
+    # or nil if none found (which will then be rootlogger)
+    def self.find_ancestor(path)
+      arr = path.split Log4rConfig::LoggerPathDelimiter
+      logger = nil
+      while arr.size > 0 do
+        logger = Repository[arr.join(Log4rConfig::LoggerPathDelimiter)]
+        break unless logger.nil?
+        arr.pop
+      end
+      logger
+    end
+
+  end
+end
+end

data/src/log4r/staticlogger.rb

@@ -0,0 +1,49 @@
+# :nodoc:
+module Log4r
+  class Logger
+    # Returns the root logger. Identical to Logger.global
+    def self.root; return RootLogger.instance end
+    # Returns the root logger. Identical to Logger.root
+    def self.global; return root end
+    
+    # Get a logger with a fullname from the repository or nil if logger
+    # wasn't found.
+
+    def self.[](_fullname)
+      # forces creation of RootLogger if it doesn't exist yet.
+      return RootLogger.instance if _fullname=='root' or _fullname=='global'
+      Repository[_fullname]
+    end
+
+    # Like Logger[] except that it raises NameError if Logger wasn't found.
+
+    def self.get(_fullname)
+      logger = self[_fullname]
+      if logger.nil?
+        raise NameError, "Logger '#{_fullname}' not found.", caller
+      end
+      logger
+    end
+
+    # Yields fullname and logger for every logger in the system.
+    def self.each
+      for fullname, logger in Repository.instance.loggers
+        yield fullname, logger
+      end
+    end
+
+    def self.each_logger
+      Repository.instance.loggers.each_value {|logger| yield logger}
+    end
+
+    # Internal logging for Log4r components. Accepts only blocks.
+    # To see such log events, create a logger named 'log4r' and give 
+    # it an outputter.
+
+    def self.log_internal(level=1)
+      internal = Logger['log4r']
+      return if internal.nil?
+      internal.send(LNAMES[level].downcase, yield)
+    end
+  end
+end

data/tests/include.rb

@@ -0,0 +1,7 @@
+$:.push("../src")
+require 'runit/testcase'
+require "log4r"
+require "log4r/configurator"
+
+include Log4r
+include RUNIT

data/tests/runtest.rb

@@ -0,0 +1,6 @@
+system "ruby testcustom.rb"
+system "ruby testbase.rb"
+system "ruby testdefault.rb"
+for i in 1..4
+  system "ruby testxmlconf.rb #{i}"
+end

data/tests/testbase.rb

@@ -0,0 +1,45 @@
+require "include"
+require "runit/cui/testrunner"
+
+# must be run independently
+class TestBase < TestCase
+  def test_default_const
+    Logger.root # create the default levels
+    assert_equal(ALL,0)
+    assert_equal(DEBUG,1)
+    assert_equal(INFO,2)
+    assert_equal(WARN,3)
+    assert_equal(ERROR,4)
+    assert_equal(FATAL,5)
+    assert_equal(OFF,6)
+    assert_equal(LEVELS, 7)
+    assert_equal(LNAMES.size, 7)
+  end
+  def test_validate
+    7.times{|i| assert_no_exception {Log4rTools.validate_level(i)} }
+    assert_exception(ArgumentError) {Log4rTools.validate_level(-1)}
+    assert_exception(ArgumentError) {Log4rTools.validate_level(LEVELS)}
+    assert_exception(ArgumentError) {Log4rTools.validate_level(String)}
+    assert_exception(ArgumentError) {Log4rTools.validate_level("bogus")}
+  end
+  def test_decode_bool
+    assert(Log4rTools.decode_bool({:data=>'true'},:data,false) == true)
+    assert(Log4rTools.decode_bool({:data=>true},:data,false) == true)
+    assert(Log4rTools.decode_bool({:data=>'false'},:data,true) == false)
+    assert(Log4rTools.decode_bool({:data=>false},:data,true) == false)
+    assert(Log4rTools.decode_bool({:data=>nil},:data,true) == true)
+    assert(Log4rTools.decode_bool({:data=>nil},:data,false) == false)
+    assert(Log4rTools.decode_bool({:data=>String},:data,true) == true)
+    assert(Log4rTools.decode_bool({:data=>String},:data,false) == false)
+    assert(Log4rTools.decode_bool({'data'=>'true'},:data,false) == true)
+    assert(Log4rTools.decode_bool({'data'=>true},:data,false) == true)
+    assert(Log4rTools.decode_bool({'data'=>'false'},:data,true) == false)
+    assert(Log4rTools.decode_bool({'data'=>false},:data,true) == false)
+    assert(Log4rTools.decode_bool({'data'=>nil},:data,true) == true)
+    assert(Log4rTools.decode_bool({'data'=>nil},:data,false) == false)
+    assert(Log4rTools.decode_bool({'data'=>String},:data,true) == true)
+    assert(Log4rTools.decode_bool({'data'=>String},:data,false) == false)
+  end
+end
+
+CUI::TestRunner.run(TestBase.suite)

data/tests/testcustom.rb

@@ -0,0 +1,33 @@
+require "include"
+require "runit/cui/testrunner"
+
+# tests the customization of Log4r levels
+class TestCustom < TestCase
+  def test_validation
+    assert_exception(TypeError) { Configurator.custom_levels "lowercase" }
+    assert_exception(TypeError) { Configurator.custom_levels "With space" }
+  end
+
+  def test_create
+    assert_no_exception { Configurator.custom_levels "Foo", "Bar", "Baz" }
+    assert_no_exception { Configurator.custom_levels }
+    assert_no_exception { Configurator.custom_levels "Bogus", "Levels" }
+  end
+  def test_methods
+    l = Logger.new 'custom1'
+    assert_respond_to(:foo, l)
+    assert_respond_to(:foo?, l)
+    assert_respond_to(:bar, l)
+    assert_respond_to(:bar?, l)
+    assert_respond_to(:baz, l)
+    assert_respond_to(:baz?, l)
+    assert_no_exception(NameError) { Bar }
+    assert_no_exception(NameError) { Baz }
+    assert_no_exception(NameError) { Foo }
+  end
+    
+end
+
+CUI::TestRunner.run(TestCustom.new("test_validation"))
+CUI::TestRunner.run(TestCustom.new("test_create"))
+CUI::TestRunner.run(TestCustom.new("test_methods"))

data/tests/testdefault.rb

@@ -0,0 +1,25 @@
+# actually, tests only the following:
+require "testlogger"
+require "testoutputter"
+require "testformatter"
+require "testpatternformatter"
+
+require "runit/testsuite"
+require "runit/cui/testrunner"
+
+class TestDefault
+  def TestDefault.suite
+    suite = TestSuite.new
+    for k in Object.constants.sort
+      next if /^Test/ !~ k
+      const = Object.const_get(k)
+      if const.kind_of?(Class) && const.superclass == RUNIT::TestCase
+        suite.add(const.suite)
+      end
+    end
+    suite
+  end
+end
+
+CUI::TestRunner.run(TestDefault.suite)
+

data/tests/testformatter.rb

@@ -0,0 +1,29 @@
+require "include"
+
+class TestFormatter < TestCase
+  def test_creation
+    assert_no_exception { Formatter.new.format(3) }
+    assert_no_exception { DefaultFormatter.new }
+    assert_kind_of(Formatter, DefaultFormatter.new)
+  end
+  def test_simple_formatter
+    sf = SimpleFormatter.new
+    f = Logger.new('simple formatter')
+    event = LogEvent.new(0, f, nil, "some data")
+    assert_match(sf.format(event), /simple formatter/)
+  end
+  def test_basic_formatter
+    b = BasicFormatter.new
+    f = Logger.new('fake formatter')
+    event = LogEvent.new(0, f, caller, "fake formatter")
+    event2 = LogEvent.new(0, f, nil, "fake formatter")
+    # this checks for tracing
+    assert_match(b.format(event), /in/)
+    assert_not_match(b.format(event2), /in/)
+    e = ArgumentError.new("argerror")
+    e.set_backtrace ['backtrace']
+    event3 = LogEvent.new(0, f, nil, e)
+    assert_match(b.format(event3), /ArgumentError/)
+    assert_match(b.format(LogEvent.new(0,f,nil,[1,2,3])), /Array/)
+  end
+end 

data/tests/testlogger.rb

@@ -0,0 +1,198 @@
+require "include"
+
+class MyFormatter1 < Formatter
+  def format(event)
+    return "MyFormatter1\n"
+  end
+end
+
+class MyFormatter2 < Formatter
+  def format(event)
+    return "MyFormatter2\n"
+  end
+end
+
+class TestLogger < TestCase
+  def test_root
+    l1 = Logger.root
+    l2 = Logger['root']
+    l3 = Logger.global
+    assert(l1 == l2, "RootLogger wasn't singleton!")
+    assert(l1 == l3)
+    assert(l1.is_root? == true, "is_root? not working")
+    assert(l1.parent == nil, "Root's parent wasn't nil!")
+  end
+  def test_validation
+    assert_exception(ArgumentError) { Logger.new }
+    assert_no_exception { Logger.new('validate', nil) }
+  end
+  def test_all_off
+    l = Logger.new("create_method")
+    l.level = WARN
+    assert(l.debug? == false)
+    assert(l.info? == false)
+    assert(l.warn? == true)
+    assert(l.error? == true)
+    assert(l.fatal? == true)
+    assert(l.off? == false)
+    assert(l.all? == false)
+    l.level = OFF
+    assert(l.off? == true)
+    assert(l.all? == false)
+    l.level = ALL
+    assert(l.off? == false)
+    assert(l.all? == true)
+  end
+  def test_add_outputters
+    StdoutOutputter.new('fake1')
+    StdoutOutputter.new('fake2')
+    a = Logger.new("add")
+    assert_exception(TypeError) { a.add 'bogus' }
+    assert_exception(TypeError) { a.add Class }
+    assert_exception(TypeError) { a.add 'fake1', Class }
+    assert_no_exception { a.add 'fake1', 'fake2' }
+  end
+  def test_repository
+    assert_exception(NameError) { Logger.get('bogusbogus') }
+    assert_no_exception { Logger['bogusbogus'] }
+  end
+  def test_heiarchy
+    a = Logger.new("a")
+    a.additive = true
+    assert(a.name == "a", "name wasn't set properly")
+    assert(a.path == "", "path wasn't set properly")
+    assert(a.level == Logger.root.level, "didn't inherit root's level") 
+    assert(a.parent == Logger.root)
+    a.level = WARN
+    b = Logger.new("a::b")
+    assert(b.name == "b", "name wasn't set properly")
+    assert(b.path == "a", "path wasn't set properly")
+    assert(b.level == a.level, "didn't inherit parent's level") 
+    assert(b.parent == a, "parent wasn't what is expected")
+    c = Logger.new("a::b::c")
+    assert(Logger["a::b::c"] == c)
+    assert(c.name == "c", "name wasn't set properly")
+    assert(c.path == "a::b", "path wasn't set properly")
+    assert(c.level == b.level, "didn't inherit parent's level") 
+    assert(c.parent == b, "parent wasn't what is expected")
+    d = Logger.new("a::d")
+    assert(Logger["a::d"] == d)
+    assert(d.name == "d", "name wasn't set properly")
+    assert(d.path == "a", "path wasn't set properly")
+    assert(d.level == a.level, "didn't inherit parent's level") 
+    assert(d.parent == a, "parent wasn't what is expected")
+    assert_exception(ArgumentError) { Logger.new("::a") }
+  end
+  def test_undefined_parents
+    a = Logger.new 'has::no::real::parents::me'
+    assert(a.parent == Logger.root)
+    b = Logger.new 'has::no::real::parents::me::child'
+    assert(b.parent == a)
+    c = Logger.new 'has::no::real::parents::metoo'
+    assert(c.parent == Logger.root)
+    p = Logger.new 'has::no::real::parents'
+    assert(p.parent == Logger.root)
+    assert(a.parent == p)
+    assert(b.parent == a)
+    assert(c.parent == p)
+    Logger.each{|fullname, logger|
+      if logger != a and logger != c
+        assert(logger.parent != p)
+      end
+    }
+  end
+  def test_levels
+    l = Logger.new("levels", WARN)
+    assert(l.level == WARN, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == true)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should show up. 3 total"
+    l.error "error messge should show up. 3 total"
+    l.fatal "fatal messge should show up. 3 total"
+    l.level = ERROR
+    assert(l.level == ERROR, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == false)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should NOT show up."
+    l.error "error messge should show up. 2 total"
+    l.fatal "fatal messge should show up. 2 total"
+    l.level = WARN
+  end
+  def test_log_blocks
+    l = Logger.new 'logblocks'
+    l.level = WARN
+    l.add(Outputter.stdout)
+    assert_no_exception {
+      l.debug { puts "should not show up"; "LOGBLOCKS" }
+      l.fatal { puts "should show up"; "LOGBLOCKS" }
+      l.fatal { nil }
+      l.fatal {}
+    }
+  end
+  def test_heiarchial_logging
+    a = Logger.new("one")
+    a.add(StdoutOutputter.new 'so1')
+    b = Logger.new("one::two")
+    b.add(StdoutOutputter.new 'so2')
+    c = Logger.new("one::two::three")
+    c.add(StdoutOutputter.new 'so3')
+    d = Logger.new("one::two::three::four")
+    d.add(StdoutOutputter.new 'so4')
+    d.additive = false
+    e = Logger.new("one::two::three::four::five")
+    e.add(StdoutOutputter.new 'so5')
+
+    a.fatal "statement from a should show up once"
+    b.fatal "statement from b should show up twice"
+    c.fatal "statement from c should show up thrice"
+    d.fatal "statement from d should show up once"
+    e.fatal "statement from e should show up twice"
+  end
+  def test_multi_outs
+    f1 = FileOutputter.new('f1', :filename => "./junk/tmp1.log", :level=>ALL)
+    f2 = FileOutputter.new('f2', :filename => "./junk/tmp2.log", :level=>DEBUG)
+    f3 = FileOutputter.new('f3', :filename => "./junk/tmp3.log", :level=>ERROR)
+    f4 = FileOutputter.new('f4', :filename => "./junk/tmp4.log", :level=>FATAL)
+
+    l = Logger.new("multi")
+    l.add(f1, f3, f4)
+
+    a = Logger.new("multi::multi2")
+    a.level = ERROR
+    a.add(f2, f4)
+    
+    l.debug "debug test_multi_outputters"
+    l.info "info test_multi_outputters"
+    l.warn "warn test_multi_outputters"
+    l.error "error test_multi_outputters"
+    l.fatal "fatal test_multi_outputters"
+
+    a.debug "debug test_multi_outputters"
+    a.info "info test_multi_outputters"
+    a.warn "warn test_multi_outputters"
+    a.error "error test_multi_outputters"
+    a.fatal "fatal test_multi_outputters"
+    
+    f1.close; f2.close; f3.close; f4.close
+  end
+  def test_custom_formatter
+    l = Logger.new('custom_formatter')
+    o = StdoutOutputter.new('formatter'=>MyFormatter1.new)
+    l.add o
+    l.error "try myformatter1"
+    l.fatal "try myformatter1"
+    o.formatter = MyFormatter2.new
+    l.error "try formatter2"
+    l.fatal "try formatter2"
+  end
+end