riess 0.0.8

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

@@ -0,0 +1,108 @@
+# :include: ../rdoc/patternformatter
+#
+# == Other Info
+#
+# Version:: $Id: patternformatter.rb,v 1.2 2002/01/28 16:05:05 cepheus Exp $
+# Author::  Leon Torres <leon@ugcs.caltech.edu>
+
+require "log4r/formatter/formatter"
+  
+module Log4r
+  # See log4r/formatter/patternformatter.rb
+  class PatternFormatter < BasicFormatter
+  
+    # Arguments to sprintf keyed to directive letters
+    DirectiveTable = {
+      "c" => 'event.name',
+      "C" => 'event.fullname',
+      "d" => 'format_date',
+      "t" => 'event.tracer[0]',
+      "m" => 'event.data',
+      "M" => 'format_object(event.data)',
+      "l" => 'LNAMES[event.level]',
+      "%" => '"%"'
+    }
+  
+    # Matches the first directive encountered and the stuff around it.
+    #
+    # * $1 is the stuff before directive or "" if not applicable
+    # * $2 is the directive group or nil if there's none
+    # * $3 is the %#.# match within directive group
+    # * $4 is the .# match which we don't use (it's there to match properly)
+    # * $5 is the directive letter
+    # * $6 is the stuff after the directive or "" if not applicable
+  
+    DirectiveRegexp = /([^%]*)((%-?\d*(\.\d+)?)([cCdtmMl%]))?(.*)/
+  
+    # default date format
+    ISO8601 = "%Y-%m-%d %H:%M:%S"
+    
+    attr_reader :pattern, :date_pattern, :date_method
+  
+    # Accepts the following hash arguments (either a string or a symbol):
+    #
+    # [<tt>pattern</tt>]         A pattern format string.
+    # [<tt>date_pattern</tt>]    A Time#strftime format string. See the
+    #                            Ruby Time class for details.
+    # [+date_method+]     
+    #   As an option to date_pattern, specify which
+    #   Time.now method to call. For 
+    #   example, +usec+ or +to_s+.
+    #   Specify it as a String or Symbol.
+    #
+    # The default date format is ISO8601, which looks like this:
+    # 
+    #   yyyy-mm-dd hh:mm:ss    =>    2001-01-12 13:15:50
+  
+    def initialize(hash={})
+      super(hash)
+      @pattern = (hash['pattern'] or hash[:pattern] or nil)
+      @date_pattern = (hash['date_pattern'] or hash[:date_pattern] or nil)
+      @date_method = (hash['date_method'] or hash[:date_method] or nil)
+      @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
+      PatternFormatter.create_format_methods(self)
+    end
+
+    # PatternFormatter works by dynamically defining a <tt>format</tt> method
+    # based on the supplied pattern format. This method contains a call to 
+    # Kernel#sptrintf with arguments containing the data requested in
+    # the pattern format.
+    #
+    # How is this magic accomplished? First, we visit each directive
+    # and change the %#.# component to  %#.#s. The directive letter is then 
+    # used to cull an appropriate entry from the DirectiveTable for the
+    # sprintf argument list. After assembling the method definition, we
+    # run module_eval on it, and voila.
+    
+    def PatternFormatter.create_format_methods(pf) #:nodoc:
+      # first, define the format_date method
+      if pf.date_method
+        module_eval "def pf.format_date; Time.now.#{pf.date_method}; end"
+      else
+        module_eval <<-EOS
+          def pf.format_date
+            Time.now.strftime "#{pf.date_pattern}"
+          end
+        EOS
+      end
+      # and now the main format method
+      ebuff = "def pf.format(event)\n sprintf(\""
+      _pattern = pf.pattern.dup
+      args = [] # the args to sprintf which we'll append to ebuff lastly
+      while true # work on each match in turn
+        match = DirectiveRegexp.match _pattern
+        ebuff += match[1] unless match[1].empty?
+        break if match[2].nil?
+        # deal with the directive by inserting a %#.#s where %#.# is copied
+        # directy from the match
+        ebuff += match[3] + "s"
+        args << DirectiveTable[match[5]] # cull the data for our argument list
+        break if match[6].empty?
+        _pattern = match[6]
+      end
+      ebuff += '\n", ' + args.join(', ') + ")\n"
+      ebuff += "end\n"
+      module_eval ebuff
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+#:nodoc:
+module Log4r
+  begin 
+    require 'romp'
+    HAVE_ROMP = true
+  rescue LoadError
+    HAVE_ROMP = false
+  end
+  
+  if HAVE_ROMP
+
+    module ROMPServer #:nodoc:
+      private
+      def start_server(_uri, accept)
+        @server = ROMP::Server.new(_uri, accept) # what if accept is nil?
+        @server.bind(self, "Log4r::LogServer")
+      end
+    end
+
+    module ROMPClient #:nodoc:
+      private
+      def connect
+        begin
+          @client = ROMP::Client.new(@uri, false)
+          @remote_logger = @client.resolve("Log4r::LogServer")
+        rescue Exception => e
+          Logger.log_internal(-2) {
+            "RemoteOutputter '#{@name}' failed to connect to #{@uri}!"
+          }
+          Logger.log_internal {e}
+          self.level = OFF
+        end
+      end
+      # we use propagated = true
+      def send_buffer
+        begin
+          @buff.each {|levent| 
+            lname = LNAMES[levent.level].downcase
+            @remote_logger.oneway(lname, levent, true)
+          }
+        rescue Exception => e
+          Logger.log_internal(-2) {"RemoteOutputter '#{@name}' can't log!"}
+          Logger.log_internal {e}
+          self.level = OFF
+        ensure @buff.clear
+        end
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+#:nodoc:
+module Log4r
+  begin
+    require 'rexml/document'
+    HAVE_REXML = true
+  rescue LoadError
+    HAVE_REXML = false
+  end
+end
+
+if Log4r::HAVE_REXML
+  module REXML #:nodoc: all
+    class Element
+      def value_of(elmt)
+        val = attributes[elmt]
+        if val.nil?
+          sub = elements[elmt]
+          val = sub.text unless sub.nil?
+        end
+        val
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# :nodoc:
+module Log4r
+
+  ##
+  # LogEvent wraps up all the miscellaneous data associated with a logging
+  # statement. It gets passed around to the varied components of Log4r and
+  # should be of interest to those creating extensions.
+  #
+  # Data contained: 
+  #
+  # [level]    The integer level of the log event. Use LNAMES[level]
+  #            to get the actual level name.
+  # [tracer]   The execution stack returned by <tt>caller</tt> at the
+  #            log event. It is nil if the invoked Logger's trace is false.
+  # [data]     The object that was passed into the logging method.
+  # [name]     The name of the logger that was invoked.
+  # [fullname] The fully qualified name of the logger that was invoked.
+  #
+  # Note that creating timestamps is a task left to formatters.
+
+  class LogEvent
+    attr_reader :level, :tracer, :data, :name, :fullname
+    def initialize(level, logger, tracer, data)
+      @level, @tracer, @data = level, tracer, data
+      @name, @fullname = logger.name, logger.fullname
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# :include: rdoc/logger
+#
+# == Other Info
+# 
+# Version:: $Id: logger.rb,v 1.24 2004/03/17 19:13:07 fando Exp $
+# Author:: Leon Torres <leon(at)ugcs.caltech.edu>
+
+require "log4r/outputter/outputter"
+require "log4r/repository"
+require "log4r/loggerfactory"
+require "log4r/staticlogger"
+
+module Log4r
+  
+  # See log4r/logger.rb
+  class Logger
+    attr_reader :name, :fullname, :path, :level, :parent
+    attr_reader :additive, :trace, :outputters
+
+    # Logger requires a name. The last 3 parameters are:
+    #
+    # level::     Do I have a level? (Otherwise, I'll inherit my parent's)
+    # additive::  Am I additive?
+    # trace::     Do I record the execution trace? (slows things a wee bit) 
+
+    def initialize(_fullname, _level=nil, _additive=true, _trace=false)
+      # validation
+      raise ArgumentError, "Logger must have a name", caller if _fullname.nil?
+      Log4rTools.validate_level(_level) unless _level.nil?
+      validate_name(_fullname)
+      
+      # create the logger
+      @fullname = _fullname
+      @outputters = []
+      @additive = _additive
+      deal_with_inheritance(_level)
+      LoggerFactory.define_methods(self)
+      self.trace = _trace
+      Repository[@fullname] = self
+    end
+
+    def validate_name(_fullname)
+      parts = _fullname.split Log4rConfig::LoggerPathDelimiter
+      for part in parts
+        raise ArgumentError, "Malformed path", caller[1..-1] if part.empty?
+      end
+    end
+    private :validate_name
+
+    # Parses name for location in heiarchy, sets the parent, and
+    # deals with level inheritance
+
+    def deal_with_inheritance(_level)
+      mypath = @fullname.split Log4rConfig::LoggerPathDelimiter
+      @name = mypath.pop
+      if mypath.empty? # then root is my daddy
+        @path = ""
+        # This is one of the guarantees that RootLogger gets created
+        @parent = Logger.root
+      else
+        @path = mypath.join(Log4rConfig::LoggerPathDelimiter)
+        @parent = Repository.find_ancestor(@path)
+        @parent = Logger.root if @parent.nil?
+      end
+      # inherit the level if no level defined
+      if _level.nil? then @level = @parent.level
+      else @level = _level end
+      Repository.reassign_any_children(self)
+    end
+    private :deal_with_inheritance
+
+    # Set the logger level dynamically. Does not affect children.
+    def level=(_level)
+      Log4rTools.validate_level(_level)
+      @level = _level
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
+      @level
+    end
+
+    # Set the additivity of the logger dynamically. True or false.
+    def additive=(_additive)
+      @additive = _additive
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' is additive"}
+      @additive
+    end
+
+    # Set whether the logger traces. Can be set dynamically. Defaults
+    # to false and understands the strings 'true' and 'false'.
+    def trace=(_trace)
+      @trace =
+        case _trace
+        when "true", true then true
+        else false end
+      LoggerFactory.define_methods(self)
+      Logger.log_internal {"Logger '#{@fullname}' is tracing"} if @trace
+      @trace
+    end
+
+    # Please don't reset the parent
+    def parent=(parent)
+      @parent = parent
+    end
+    
+    # Set the Outputters dynamically by name or reference. Can be done any
+    # time.
+    def outputters=(_outputters)
+      @outputters.clear
+      add(*_outputters)
+    end  
+
+    # Add outputters by name or by reference. Can be done any time.
+    def add(*_outputters)
+      for thing in _outputters
+        o = (thing.kind_of?(Outputter) ? thing : Outputter[thing])
+        # some basic validation
+        if not o.kind_of?(Outputter)
+          raise TypeError, "Expected kind of Outputter, got #{o.class}", caller
+        elsif o.nil?
+          raise TypeError, "Couldn't find Outputter '#{thing}'", caller
+        end
+        @outputters.push o
+        Logger.log_internal {"Added outputter '#{o.name}' to '#{@fullname}'"}
+      end
+      @outputters
+    end
+
+    # Remove outputters from this logger by name only. Can be done any time.
+    def remove(*_outputters)
+      for name in _outputters
+        o = Outputter[name]
+        @outputters.delete o
+        Logger.log_internal {"Removed outputter '#{o.name}' from '#{@fullname}'"}
+      end
+    end
+
+    def is_root?; false end
+
+    def ==(other)
+      return true if id == other.id
+    end
+  end
+
+
+  # RootLogger should be retrieved with Logger.root or Logger.global.
+  # It's supposed to be transparent.
+  #--
+  # We must guarantee the creation of RootLogger before any other Logger
+  # or Outputter gets their logging methods defined. There are two 
+  # guarantees in the code:
+  #
+  # * Logger#deal_with_inheritance - calls RootLogger.instance when
+  #   a new Logger is created without a parent. Parents must exist, therefore
+  #   RootLogger is forced to be created.
+  #
+  # * OutputterFactory.create_methods - Calls Logger.root first. So if
+  #   an Outputter is created, RootLogger is also created.
+  #
+  # When RootLogger is created, it calls
+  # Log4r.define_levels(*Log4rConfig::LogLevels). This ensures that the 
+  # default levels are loaded if no custom ones are.
+
+  class RootLogger < Logger
+    include Singleton
+
+    def initialize
+      Log4r.define_levels(*Log4rConfig::LogLevels) # ensure levels are loaded
+      @level = ALL
+      @outputters = []
+      Repository['root'] = self
+      Repository['global'] = self
+      LoggerFactory.undefine_methods(self)
+    end
+
+    def is_root?; true end
+
+    # Set the global level. Any loggers defined thereafter will
+    # not log below the global level regardless of their levels.
+
+    def level=(alevel); @level = alevel end
+
+    # Does nothing
+    def outputters=(foo); end
+    # Does nothing
+    def trace=(foo); end
+    # Does nothing
+    def additive=(foo); end
+    # Does nothing
+    def add(*foo); end
+    # Does nothing
+    def remove(*foo); end
+  end
+end

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

@@ -0,0 +1,89 @@
+# :nodoc:
+# Version:: $Id: loggerfactory.rb,v 1.11 2002/01/28 16:05:05 cepheus Exp $
+
+require "log4r/base"
+require "log4r/repository"
+require 'log4r/logevent'
+
+module Log4r
+class Logger
+  class LoggerFactory #:nodoc:
+
+    # we want to log iff root.lev <= lev && logger.lev <= lev
+    # BTW, root is guaranteed to be defined by this point
+    def self.define_methods(logger)
+      return if logger.is_root?
+      undefine_methods(logger)
+      globlev = Repository['root'].level
+      return if logger.level == OFF or globlev == OFF
+      toggle_methods(globlev, logger)
+    end
+
+    # set logging methods to null defaults
+    def self.undefine_methods(logger)
+      for lname in LNAMES
+        next if lname == 'OFF'|| lname == 'ALL'
+        unset_log(logger, lname)
+        set_false(logger, lname)
+      end
+      set_false(logger, 'all')
+      set_true(logger, 'off')
+    end
+    
+    # toggle methods >= globlev that are also >= level
+    def self.toggle_methods(globlev, logger)
+      for lev in globlev...LEVELS # satisfies >= globlev
+        next if lev < logger.level # satisfies >= level
+        next if LNAMES[lev] == 'OFF'
+        next if LNAMES[lev] == 'ALL'
+        set_log(logger, LNAMES[lev])
+        set_true(logger, LNAMES[lev])
+      end
+      if logger.level == ALL
+        set_true(logger, 'all')
+      end
+      if logger.level != OFF && globlev != OFF
+        set_false(logger, 'off')
+      end
+    end
+
+    # And now, the weird dynamic method definitions! :)
+  
+    def self.unset_log(logger, lname)
+      mstr="def logger.#{lname.downcase}(data=nil, propagated=false); end"
+      module_eval mstr
+    end
+    
+    # Logger logging methods are defined here.
+    def self.set_log(logger, lname) 
+      # invoke caller iff the logger invoked is tracing
+      tracercall = (logger.trace ? "caller" : "nil")
+      # maybe pass parent a logevent. second arg is the switch
+      if logger.additive && !logger.parent.is_root?
+        parentcall = "@parent.#{lname.downcase}(event, true)"
+      end
+      mstr = %-
+        def logger.#{lname.downcase}(data=nil, propagated=false)
+          if propagated then event = data
+          else
+            data = yield if block_given?
+            event = LogEvent.new(#{lname}, self, #{tracercall}, data)
+          end
+          @outputters.each {|o| o.#{lname.downcase}(event) }
+          #{parentcall}
+        end
+      -
+      module_eval mstr
+    end
+    
+    def self.set_false(logger, lname)
+      module_eval "def logger.#{lname.downcase}?; false end"
+    end
+
+    def self.set_true(logger, lname)
+      module_eval "def logger.#{lname.downcase}?; true end"
+    end
+
+  end
+end
+end