riess 0.0.8

data/vendor/log4r-1.0.5/examples/simpleconfig.rb

@@ -0,0 +1,39 @@
+# Simple configuration example.
+# Where we configure just one logger and make it log to a file and stdout.
+
+# add the path to log4r if it isn't installed in a ruby path
+$: << File.join('..','src')
+require "log4r"
+
+# First things first, get the root logger and set its level to WARN.
+# This makes the global level WARN. Later on, we can turn off all logging
+# by setting it to OFF right here (or dynamically if you prefer)
+Log4r::Logger.root.level = Log4r::WARN
+
+# Remember: By specifying a level, we are saying "Include this level and
+# anything worse." So in this case, we're logging WARN, ERROR and FATAL
+
+# create a logger
+log = Log4r::Logger.new("simpleconf")
+
+# We want to log to $stderr and a file ./tmp.log
+
+# Create an outputter for $stderr. It defaults to the root level WARN
+Log4r::StderrOutputter.new 'console'
+# for the file, we want to log only FATAL and ERROR and don't trunc
+Log4r::FileOutputter.new('logfile', 
+                         :filename=>'logs/simple.log', 
+                         :trunc=>false,
+                         :level=>Log4r::FATAL)
+
+# add the outputters (this method accepts outputter names or references)
+log.add('console','logfile')
+
+# Now let's try it out:
+log.debug "debugging"
+log.info "a piece of info"
+log.warn "Danger, Will Robinson, danger!"
+log.error "I dropped my Wookie! :("
+log.fatal "kaboom!"
+
+# now run this and compare output to ./tmp.log

data/vendor/log4r-1.0.5/examples/xmlconfig.rb

@@ -0,0 +1,25 @@
+# This is like moderateconfig.rb, but using an XML config
+# please look at moderate.xml
+
+$: << '../src'
+
+require 'log4r'
+require 'log4r/configurator'
+include Log4r
+
+# set any runtime XML variables
+Configurator['logpath'] = './logs'
+# Load up the config file
+Configurator.load_xml_file('./moderate.xml')
+
+# now repeat what moderateconfig.rb does
+def do_logging(log)
+log.debug "debugging"
+log.info "a piece of info"
+log.warn "Danger, Will Robinson, danger!"
+log.error "I dropped my Wookie! :("
+log.fatal "kaboom!"
+end
+
+Logger.each_logger{|logger| do_logging(logger) }
+# stop here

data/vendor/log4r-1.0.5/examples/yaml.rb

@@ -0,0 +1,30 @@
+# Log4r can be configured using YAML. This example uses log4r_yaml.yaml
+
+$: << File.join('..','src') # path if log4r is not installed
+require 'log4r'
+require 'log4r/yamlconfigurator'
+# we use various outputters, so require them, otherwise config chokes
+require 'log4r/outputter/datefileoutputter'
+require 'log4r/outputter/emailoutputter'
+include Log4r
+
+cfg = YamlConfigurator # shorthand
+cfg['HOME'] = '.'      # the only parameter in the YAML, our HOME directory
+
+# load the YAML file with this
+cfg.load_yaml_file('log4r_yaml.yaml')
+
+# Method to log each of the custom levels
+def do_logging(log)
+  log.deb "This is DEB"
+  log.inf "This is INF"
+  log.prt "This is PRT"
+  log.wrn "This is WRN"
+  log.err "This is ERR"
+  log.fat "This is FAT"
+end
+
+# turn off the email outputter
+Outputter['email'].level = OFF
+# the other two outputters log to stderr and a timestamped file in ./logs
+do_logging( Logger['mylogger'])

data/vendor/log4r-1.0.5/src/log4r.rb

@@ -0,0 +1,20 @@
+# :include: log4r/rdoc/log4r
+#
+# == Other Info
+#
+# Author::      Leon Torres
+# Version::     $Id: log4r.rb,v 1.10 2002/08/20 04:15:04 cepheus Exp $
+
+vendor_path = __FILE__.gsub('log4r.rb','')
+$LOAD_PATH << vendor_path
+
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/consoleoutputters"
+require "log4r/outputter/staticoutputter"
+require "log4r/outputter/rollingfileoutputter"
+require "log4r/formatter/patternformatter"
+require "log4r/loggerfactory"
+
+module Log4r
+  Log4rVersion = [1, 0, 1].join '.'
+end

data/vendor/log4r-1.0.5/src/log4r/base.rb

@@ -0,0 +1,74 @@
+# :nodoc:
+require "log4r/config"
+
+module Log4r
+  ALL = 0
+  LNAMES = ['ALL']
+
+  # Defines the log levels of the Log4r module at runtime. It is given
+  # either the default level spec (when root logger is created) or the
+  # user-specified level spec (when Logger.custom_levels is called).
+  #
+  # The last constant defined by this method is OFF. Other level-sensitive 
+  # parts of the code check to see if OFF is defined before deciding what 
+  # to do. The typical action would be to force the creation of RootLogger 
+  # so that the custom levels get loaded and business can proceed as usual.
+  #
+  # For purposes of formatting, a constant named MaxLevelLength is defined
+  # in this method. It stores the max level name string size.
+
+  def Log4r.define_levels(*levels) #:nodoc:
+    return if const_defined? :OFF
+    for i in 0...levels.size
+      name = levels[i].to_s
+      module_eval "#{name} = #{i} + 1; LNAMES.push '#{name}'"
+    end
+    module_eval %{
+      LNAMES.push 'OFF'
+      LEVELS = LNAMES.size
+      OFF = LEVELS - 1
+      MaxLevelLength = Log4rTools.max_level_str_size
+    }
+  end
+
+  # Some common functions 
+  class Log4rTools
+    # Raises ArgumentError if level argument is an invalid level. Depth
+    # specifies how many trace entries to remove.
+    def self.validate_level(level, depth=0)
+      unless valid_level?(level)
+        raise ArgumentError, "Log level must be in 0..#{LEVELS}",
+              caller[1..-(depth + 1)]
+      end
+    end
+    
+    def self.valid_level?(lev)
+      not lev.nil? and lev.kind_of?(Numeric) and lev >= ALL and lev <= OFF
+    end
+    
+    def self.max_level_str_size #:nodoc:
+      size = 0
+      LNAMES.each {|i| size = i.length if i.length > size}
+      size
+    end
+  
+    # Shortcut for decoding 'true', 'false', true, false or nil into a bool
+    # from a hash parameter. E.g., it looks for true/false values for
+    # the keys 'symbol' and :symbol.
+
+    def self.decode_bool(hash, symbol, default)
+      data = hash[symbol]
+      data = hash[symbol.to_s] if data.nil?
+      return case data
+        when 'true',true then true
+        when 'false',false then false
+        else default
+        end
+    end
+
+    # Splits comma-delimited lists with arbitrary \s padding
+    def self.comma_split(string)
+      string.split(/\s*,\s*/).collect {|s| s.strip}
+    end
+  end
+end

data/vendor/log4r-1.0.5/src/log4r/config.rb

@@ -0,0 +1,9 @@
+# :nodoc:
+# Version:: $Id: config.rb,v 1.9 2002/01/28 16:05:04 cepheus Exp $
+
+module Log4r
+  module Log4rConfig #:nodoc:
+    LogLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+    LoggerPathDelimiter = '::'
+  end    
+end

data/vendor/log4r-1.0.5/src/log4r/configurator.rb

@@ -0,0 +1,224 @@
+# :include: rdoc/configurator
+#
+# == Other Info
+#
+# Version:: $Id: configurator.rb,v 1.12 2004/03/17 19:13:07 fando Exp $
+
+require "log4r/logger"
+require "log4r/outputter/staticoutputter"
+require "log4r/lib/xmlloader"
+require "log4r/logserver"
+require "log4r/outputter/remoteoutputter"
+
+# TODO: catch unparsed parameters #{FOO} and die
+module Log4r
+  # Gets raised when Configurator encounters bad XML.
+  class ConfigError < Exception
+  end
+
+  # See log4r/configurator.rb
+  class Configurator
+    include REXML if HAVE_REXML
+    @@params = Hash.new
+
+    # Get a parameter's value
+    def self.[](param); @@params[param] end
+    # Define a parameter with a value
+    def self.[]=(param, value); @@params[param] = value end
+
+    # Sets the custom levels. This method accepts symbols or strings.
+    #
+    #   Configurator.custom_levels('My', 'Custom', :Levels)
+    #
+    # Alternatively, you can specify custom levels in XML:
+    # 
+    #   <log4r_config>
+    #     <pre_config>
+    #       <custom_levels>
+    #         My, Custom, Levels
+    #       </custom_levels>
+    #       ...
+
+    def self.custom_levels(*levels)
+      return Logger.root if levels.size == 0
+      for i in 0...levels.size
+        name = levels[i].to_s
+        if name =~ /\s/ or name !~ /^[A-Z]/
+          raise TypeError, "#{name} is not a valid Ruby Constant name", caller
+        end
+      end
+      Log4r.define_levels *levels
+    end
+
+    # Given a filename, loads the XML configuration for Log4r.
+    def self.load_xml_file(filename)
+      detect_rexml
+      actual_load Document.new(File.new(filename))
+    end
+
+    # You can load a String XML configuration instead of a file.
+    def self.load_xml_string(string)
+      detect_rexml
+      actual_load Document.new(string)
+    end
+
+    #######
+    private
+    #######
+
+    def self.detect_rexml
+      unless HAVE_REXML
+        raise LoadError,
+        "Need REXML to load XML configuration", caller[1..-1]
+      end
+    end
+
+    def self.actual_load(doc)
+      confignode = doc.elements['//log4r_config']
+      if confignode.nil?
+        raise ConfigError, 
+        "<log4r_config> element not defined", caller[1..-1]
+      end
+      decode_xml(confignode)
+    end
+    
+    def self.decode_xml(doc)
+      decode_pre_config(doc.elements['pre_config'])
+      doc.elements.each('outputter') {|e| decode_outputter(e)}
+      doc.elements.each('logger') {|e| decode_logger(e)}
+      doc.elements.each('logserver') {|e| decode_logserver(e)}
+    end
+
+    def self.decode_pre_config(e)
+      return Logger.root if e.nil?
+      decode_custom_levels(e.elements['custom_levels'])
+      global_config(e.elements['global'])
+      global_config(e.elements['root'])
+      decode_parameters(e.elements['parameters'])
+      e.elements.each('parameter') {|p| decode_parameter(p)}
+    end
+
+    def self.decode_custom_levels(e)
+      return Logger.root if e.nil? or e.text.nil?
+      begin custom_levels *Log4rTools.comma_split(e.text)
+      rescue TypeError => te
+        raise ConfigError, te.message, caller[1..-4]
+      end
+    end
+    
+    def self.global_config(e)
+      return if e.nil?
+      globlev = e.value_of 'level'
+      return if globlev.nil?
+      lev = LNAMES.index(globlev)     # find value in LNAMES
+      Log4rTools.validate_level(lev, 4)  # choke on bad level
+      Logger.global.level = lev
+    end
+
+    def self.decode_parameters(e)
+      e.elements.each{|p| @@params[p.name] = p.text} unless e.nil?
+    end
+
+    def self.decode_parameter(e)
+      @@params[e.value_of('name')] = e.value_of 'value'
+    end
+
+    def self.decode_outputter(e)
+      # fields
+      name = e.value_of 'name'
+      type = e.value_of 'type'
+      level = e.value_of 'level'
+      only_at = e.value_of 'only_at'
+      # validation
+      raise ConfigError, "Outputter missing name", caller[1..-3] if name.nil?
+      raise ConfigError, "Outputter missing type", caller[1..-3] if type.nil?
+      Log4rTools.validate_level(LNAMES.index(level)) unless level.nil?
+      only_levels = []
+      unless only_at.nil?
+        for lev in Log4rTools.comma_split(only_at)
+          alev = LNAMES.index(lev)
+          Log4rTools.validate_level(alev, 3)
+          only_levels.push alev
+        end
+      end
+      formatter = decode_formatter(e.elements['formatter'])
+      # build the eval string
+      buff = "Outputter[name] = #{type}.new name"
+      buff += ",:level=>#{LNAMES.index(level)}" unless level.nil?
+      buff += ",:formatter=>formatter" unless formatter.nil?
+      params = decode_hash_params(e)
+      buff += "," + params.join(',') if params.size > 0
+      begin eval buff
+      rescue Exception => ae
+        raise ConfigError, 
+        "Problem creating outputter: #{ae.message}", caller[1..-3]
+      end
+      Outputter[name].only_at *only_levels if only_levels.size > 0
+      Outputter[name]
+    end
+
+    def self.decode_formatter(e)
+      return nil if e.nil?
+      type = e.value_of 'type' 
+      raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
+      buff = "#{type}.new " + decode_hash_params(e).join(',')
+      begin return eval(buff)
+      rescue Exception => ae
+        raise ConfigError,
+        "Problem creating outputter: #{ae.message}", caller[1..-4]
+      end
+    end
+
+    ExcludeParams = %w{formatter level name type}
+
+    # Does the fancy parameter to hash argument transformation
+    def self.decode_hash_params(e)
+      buff = []
+      e.attributes.each_attribute {|p| 
+        next if ExcludeParams.include? p.name
+        buff << ":" + p.name + "=>" + paramsub(p.value)
+      }
+      e.elements.each {|p| 
+        next if ExcludeParams.include? p.name
+        buff << ":" + p.name + "=>" + paramsub(p.text)
+      }
+      buff
+    end
+    
+    # Substitues any #{foo} in the XML with Parameter['foo']
+    def self.paramsub(str)
+      return nil if str.nil?
+      @@params.each {|param, value| str.sub! '#{'+param+'}', value}
+      "'" + str + "'"
+    end
+
+    def self.decode_logger(e)
+      l = Logger.new e.value_of('name')
+      decode_logger_common(l, e)
+    end
+
+    def self.decode_logserver(e)
+      return unless HAVE_REXML
+      name = e.value_of 'name'
+      uri = e.value_of 'uri'
+      l = LogServer.new name, uri
+      decode_logger_common(l, e)
+    end
+
+    def self.decode_logger_common(l, e)
+      level = e.value_of 'level'
+      additive = e.value_of 'additive'
+      trace = e.value_of 'trace'
+      l.level = LNAMES.index(level) unless level.nil?
+      l.additive = additive unless additive.nil?
+      l.trace = trace unless trace.nil?
+      # and now for outputters
+      outs = e.value_of 'outputters'
+      Log4rTools.comma_split(outs).each {|n| l.add n.strip} unless outs.nil?
+      e.elements.each('outputter') {|e|
+        name = (e.value_of 'name' or e.text)
+        l.add Outputter[name]
+      }
+    end
+  end
+end

data/vendor/log4r-1.0.5/src/log4r/formatter/formatter.rb

@@ -0,0 +1,105 @@
+# :include: ../rdoc/formatter
+#
+# Version:: $Id: formatter.rb,v 1.7 2003/09/01 22:33:20 cepheus Exp $
+
+require "singleton"
+
+require "log4r/base"
+
+module Log4r
+
+  # Formatter is an abstract class and a null object
+  class Formatter
+    def initialize(hash={})
+    end
+    # Define this method in a subclass to format data.
+    def format(logevent)
+    end
+  end
+
+  # SimpleFormatter produces output like this:
+  # 
+  #   WARN loggername> Danger, Will Robinson, danger!
+  #
+  # Does not write traces and does not inspect objects.
+  
+  class SimpleFormatter < Formatter
+    def format(event)
+      sprintf("%*s %s> %s\n", MaxLevelLength, LNAMES[event.level], 
+              event.name, event.data)
+    end
+  end
+
+  # BasicFormatter produces output like this:
+  # 
+  #   WARN loggername: I dropped my Wookie!
+  #   
+  # Or like this if trace is on:
+  # 
+  #   WARN loggername(file.rb at 12): Hot potato!
+  #   
+  # Also, it will pretty-print any Exception it gets and
+  # +inspect+ everything else.
+  #
+  # Hash arguments include:
+  #
+  # +depth+::  How many lines of the stacktrace to display.
+
+  class BasicFormatter < SimpleFormatter
+    @@basicformat = "%*s %s"
+
+    def initialize(hash={})
+      @depth = (hash[:depth] or hash['depth'] or 7).to_i
+    end
+    
+    def format(event)
+      buff = sprintf(@@basicformat, MaxLevelLength, LNAMES[event.level],
+             event.name)
+      buff += (event.tracer.nil? ? "" : "(#{event.tracer[0]})") + ": "
+      buff += format_object(event.data) + "\n"
+      buff
+    end
+
+    # Formats data according to its class:
+    #
+    # String::     Prints it out as normal.
+    # Exception::  Produces output similar to command-line exceptions.
+    # Object::     Prints the type of object, then the output of
+    #              +inspect+. An example -- Array: [1, 2, 3]
+
+    def format_object(obj)
+      if obj.kind_of? Exception
+        return "Caught #{obj.class}: #{obj.message}\n\t" +\
+               obj.backtrace[0...@depth].join("\n\t")
+      elsif obj.kind_of? String
+        return obj
+      else # inspect the object
+        return "#{obj.class}: #{obj.inspect}"
+      end
+    end
+  end
+
+  # Formats objects the same way irb does:
+  #
+  #   loggername:foo.rb in 12> 
+  #   [1, 3, 4]
+  #   loggername:foo.rb in 13> 
+  #   {1=>"1"}
+  #
+  # Strings don't get inspected. just printed. The trace is optional.
+
+  class ObjectFormatter < Formatter
+    def format(event)
+      buff = event.logger.name
+      buff += (event.tracer.nil? ? "" : ":#{event.tracer[0]}") + ">\n"
+      buff += (event.data.kind_of?(String) ? event.data : event.data.inspect)
+      buff += "\n"
+    end
+  end
+  
+  # Outputters that don't define a Formatter will get this, which
+  # is currently BasicFormatter
+  class DefaultFormatter < BasicFormatter
+  end
+  
+end